Attachment #46883 for bug #151896

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;

import org.apache.commons.httpclient.protocol.Protocol;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylar.context.core.MylarStatusHandler;
import org.eclipse.mylar.internal.tasks.core.SslProtocolSocketFactory;
import org.eclipse.mylar.internal.tasks.ui.views.TaskRepositoriesView;
import org.eclipse.mylar.internal.trac.core.TracException;
import org.eclipse.mylar.internal.trac.core.TracLoginException;


	public void start(BundleContext context) throws Exception {
		super.start(context);

		// TODO the protocol configuration of HttpClient should not be registered globally
		Protocol acceptAllSsl = new Protocol("https", new SslProtocolSocketFactory(), 443);
		Protocol.registerProtocol("https", acceptAllSsl);

		// TODO the logging configuration of HttpClient should be done elsewhere
		System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
		System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire.header", "off");
		System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.commons.httpclient", "off");
	}

	public void stop(BundleContext context) throws Exception {

Lines 10-16 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
10	org.eclipse.core.runtime,	10	org.eclipse.core.runtime,
11	org.eclipse.mylar.context.core,	11	org.eclipse.mylar.context.core,
12	org.eclipse.mylar.tasks.ui,	12	org.eclipse.mylar.tasks.ui,
13	org.apache.xmlrpc,
14	org.eclipse.mylar.tasks.core	13	org.eclipse.mylar.tasks.core
15	Eclipse-LazyStart: true	14	Eclipse-LazyStart: true
16	Export-Package: org.eclipse.mylar.internal.trac,	15	Export-Package: org.eclipse.mylar.internal.trac,




package org.eclipse.mylar.internal.trac.core;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.xmlrpc.XmlRpc;
import org.apache.xmlrpc.XmlRpcClient;
import org.apache.xmlrpc.XmlRpcClientException;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.mylar.context.core.MylarStatusHandler;
import org.eclipse.mylar.internal.trac.core.TracHttpClientTransportFactory.TracHttpException;
import org.eclipse.mylar.internal.trac.model.TracComponent;
import org.eclipse.mylar.internal.trac.model.TracMilestone;
import org.eclipse.mylar.internal.trac.model.TracPriority;

			return xmlrpc;
		}

		XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
		config.setEncoding(ITracClient.CHARSET);
		config.setBasicUserName(username);
		config.setBasicPassword(password);
		config.setServerURL(getXmlRpcUrl());
		
		xmlrpc = new XmlRpcClient();
		xmlrpc.setConfig(config);
		
		TracHttpClientTransportFactory factory = new TracHttpClientTransportFactory(xmlrpc);
		xmlrpc.setTransportFactory(factory);

		return xmlrpc;
	}

	private URL getXmlRpcUrl() throws TracException {
		try {
			String location = repositoryUrl.toString();
			if (hasAuthenticationCredentials()) {

			}
			location += XMLRPC_URL;

			return new URL(location);
			TransportFactory transport = new TransportFactory(url);
			xmlrpc = new XmlRpcClient(url, transport);
		} catch (Exception e) {
			throw new TracException(e);
		}

		return xmlrpc;
	}

	private Object call(String method, Object... parameters) throws TracException {
		getClient();

		Vector<Object> params = new Vector<Object>();
		for (Object parameter : parameters) {
			params.add(parameter);
		}

		try {
			return xmlrpc.execute(method, parameters);
		} catch (TracHttpException e) {
			if (e.code == HttpURLConnection.HTTP_FORBIDDEN
					|| e.code == HttpURLConnection.HTTP_UNAUTHORIZED) {
				throw new TracLoginException();
			} else {
				throw new TracException(e);

		}
	}

	private Object[] multicall(Map<String, Object>... calls) throws TracException {
		Object[] result = (Object[]) call("system.multicall", new Object[] { calls });
		for (Object item : result) {
			try {
				checkForException(item);

	}

	private void checkForException(Object result) throws NumberFormatException, XmlRpcException {
		if (result instanceof Map) {
			Map exceptionData = (Map) result;
			if (exceptionData.containsKey("faultCode") && exceptionData.containsKey("faultString")) {
				throw new XmlRpcException(Integer.parseInt(exceptionData.get("faultCode").toString()),
						(String) exceptionData.get("faultString"));

		}
	}

	private Map<String, Object> createMultiCall(String methodName, Object... parameters) throws TracException {
		Map<String, Object> table = new HashMap<String, Object>();
		table.put("methodName", methodName);
		table.put("params", parameters);
		return table;
	}

	private Object getMultiCallResult(Object item) {
		return ((Object[]) item)[0];
	}

	public void validate() throws TracException {
		Object[] result = (Object[]) call("system.listMethods");
		boolean hasGetTicket = false, hasQuery = false;
		for (Object methodName : result) {
			if ("ticket.get".equals(methodName)) {

	}

	public TracTicket getTicket(int id) throws TracException {
		Object[] result = (Object[]) call("ticket.get", id);
		return parseTicket(result);
	}

	@SuppressWarnings("unchecked")
	public List<TracTicket> getTickets(int[] ids) throws TracException {
		Map<String, Object>[] calls = new Map[ids.length];
		for (int i = 0; i < calls.length; i++) {
			calls[i] = createMultiCall("ticket.get", ids[i]);
		}

		Object[] result = multicall(calls);
		assert result.length == ids.length;

		List<TracTicket> tickets = new ArrayList<TracTicket>(result.length);
		for (Object item : result) {
			Object[] ticketResult = (Object[]) getMultiCallResult(item);
			tickets.add(parseTicket(ticketResult));
		}


	@SuppressWarnings("unchecked")
	public void search(TracSearch query, List<TracTicket> tickets) throws TracException {
		// an empty query string is not valid, therefore prepend order
		Object[] result = (Object[]) call("ticket.query", "order=id" + query.toQuery());

		Map<String, Object>[] calls = new Map[result.length];
		for (int i = 0; i < calls.length; i++) {
			calls[i] = createMultiCall("ticket.get", result[i]);
		}
		result = multicall(calls);

		for (Object item : result) {
			Object[] ticketResult = (Object[]) getMultiCallResult(item);
			tickets.add(parseTicket(ticketResult));
		}
	}

	private TracTicket parseTicket(Object[] ticketResult) throws InvalidTicketException {
		TracTicket ticket = new TracTicket((Integer) ticketResult[0]);
		ticket.setCreated((Integer) ticketResult[1]);
		ticket.setLastChanged((Integer) ticketResult[2]);
		Map attributes = (Map) ticketResult[3];
		for (Object key : attributes.keySet()) {
			ticket.putTracValue(key.toString(), attributes.get(key).toString());
		}

	public synchronized void updateAttributes(IProgressMonitor monitor) throws TracException {
		monitor.beginTask("Updating attributes", 8);

		Object[] result = getAttributes("ticket.component");
		components = new ArrayList<TracComponent>(result.length);
		for (Object item : result) {
			components.add(parseComponent((Map) getMultiCallResult(item)));
		}
		monitor.worked(1);
		if (monitor.isCanceled())
			throw new OperationCanceledException();

		result = getAttributes("ticket.milestone");
		milestones = new ArrayList<TracMilestone>(result.length);
		for (Object item : result) {
			milestones.add(parseMilestone((Map) getMultiCallResult(item)));
		}
		monitor.worked(1);
		if (monitor.isCanceled())
			throw new OperationCanceledException();

		List<TicketAttributeResult> attributes = getTicketAttributes("ticket.priority");
		priorities = new ArrayList<TracPriority>(result.length);
		for (TicketAttributeResult attribute : attributes) {
			priorities.add(new TracPriority(attribute.name, attribute.value));
		}

			throw new OperationCanceledException();

		attributes = getTicketAttributes("ticket.resolution");
		ticketResolutions = new ArrayList<TracTicketResolution>(result.length);
		for (TicketAttributeResult attribute : attributes) {
			ticketResolutions.add(new TracTicketResolution(attribute.name, attribute.value));
		}

			throw new OperationCanceledException();

		attributes = getTicketAttributes("ticket.severity");
		severities = new ArrayList<TracSeverity>(result.length);
		for (TicketAttributeResult attribute : attributes) {
			severities.add(new TracSeverity(attribute.name, attribute.value));
		}

			throw new OperationCanceledException();

		attributes = getTicketAttributes("ticket.status");
		ticketStatus = new ArrayList<TracTicketStatus>(result.length);
		for (TicketAttributeResult attribute : attributes) {
			ticketStatus.add(new TracTicketStatus(attribute.name, attribute.value));
		}

			throw new OperationCanceledException();

		attributes = getTicketAttributes("ticket.type");
		ticketTypes = new ArrayList<TracTicketType>(result.length);
		for (TicketAttributeResult attribute : attributes) {
			ticketTypes.add(new TracTicketType(attribute.name, attribute.value));
		}

			throw new OperationCanceledException();

		result = getAttributes("ticket.version");
		versions = new ArrayList<TracVersion>(result.length);
		for (Object item : result) {
			versions.add(parseVersion((Map) getMultiCallResult(item)));
		}
		monitor.worked(1);
		if (monitor.isCanceled())
			throw new OperationCanceledException();
	}

	private TracComponent parseComponent(Map result) {
		TracComponent component = new TracComponent((String) result.get("name"));
		component.setOwner((String) result.get("owner"));
		component.setDescription((String) result.get("description"));
		return component;
	}

	private TracMilestone parseMilestone(Map result) {
		TracMilestone milestone = new TracMilestone((String) result.get("name"));
		milestone.setCompleted(TracUtils.parseDate((Integer) result.get("completed")));
		milestone.setDue(TracUtils.parseDate((Integer) result.get("due")));

		return milestone;
	}

	private TracVersion parseVersion(Map result) {
		TracVersion version = new TracVersion((String) result.get("name"));
		version.setTime(TracUtils.parseDate((Integer) result.get("time")));
		version.setDescription((String) result.get("description"));

	}

	@SuppressWarnings("unchecked")
	private Object[] getAttributes(String attributeType) throws TracException {
		Object[] ids = (Object[]) call(attributeType + ".getAll");
		Map<String, Object>[] calls = new Map[ids.length];
		for (int i = 0; i < calls.length; i++) {
			calls[i] = createMultiCall(attributeType + ".get", ids[i]);
		}

		Object[] result = multicall(calls);
		assert result.length == ids.length;

		return result;
	}

	@SuppressWarnings("unchecked")
	private List<TicketAttributeResult> getTicketAttributes(String attributeType) throws TracException {
		Object[] ids = (Object[]) call(attributeType + ".getAll");
		Map<String, Object>[] calls = new Map[ids.length];
		for (int i = 0; i < calls.length; i++) {
			calls[i] = createMultiCall(attributeType + ".get", ids[i]);
		}

		Object[] result = multicall(calls);
		assert result.length == ids.length;

		List<TicketAttributeResult> attributes = new ArrayList<TicketAttributeResult>(result.length);
		for (int i = 0; i < calls.length; i++) {
			try {
				TicketAttributeResult attribute = new TicketAttributeResult();
				attribute.name = (String) ids[i];
				attribute.value = Integer.parseInt((String) getMultiCallResult(result[i]));
				attributes.add(attribute);
			} catch (NumberFormatException e) {
				MylarStatusHandler.log(e, "Invalid response from Trac repository for attribute type: '" + attributeType


	}

	/**
	 * A custom transport factory used to establish XML-RPC connections. Uses
	 * the Eclipse proxy settings.
	 * 
	 * @author Steffen Pingel
	 */
	private class TransportFactory implements XmlRpcTransportFactory {

		private URL url;

		public TransportFactory(URL url) {
			assert url != null;

			this.url = url;
		}

		public XmlRpcTransport createTransport() throws XmlRpcClientException {
			return new XmlRpcTransport() {

				private HttpURLConnection connection;

				public void endClientRequest() throws XmlRpcClientException {
					assert connection != null;

					try {
						connection.getInputStream().close();
					} catch (Exception e) {
						throw new XmlRpcClientException("Exception closing connection", e);
					}
				}

				public InputStream sendXmlRpc(byte[] request) throws IOException, XmlRpcClientException {
					try {
						connection = MylarTracPlugin.getHttpConnection(url);
					} catch (Exception e) {
						throw new IOException(e.toString());
					}

					connection.setDoInput(true);
					connection.setDoOutput(true);
					connection.setUseCaches(false);
					connection.setAllowUserInteraction(false);

					connection.setRequestProperty("Content-Length", request.length + "");
					connection.setRequestProperty("Content-Type", "text/xml");
					if (hasAuthenticationCredentials()) {
						MylarTracPlugin.setAuthCredentials(connection, username, password);
					}

					OutputStream out = connection.getOutputStream();
					out.write(request);
					out.flush();
					out.close();

					connection.connect();
					int responseCode = connection.getResponseCode();
					if (responseCode != HttpURLConnection.HTTP_OK) {
						throw new HttpException(responseCode);
					}

					return connection.getInputStream();
				}

			};
		}

		public void setProperty(String key, Object value) {
			// ignore, this is never called by the library
		}

	}

	private class HttpException extends IOException {

		private static final long serialVersionUID = 7083228933121822248L;

		final int responseCode;

		public HttpException(int responseCode) {
			super("HTTP Error " + responseCode);

			this.responseCode = responseCode;
		}

	}

}




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.trac.core;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.Proxy;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcCommonsTransport;
import org.apache.xmlrpc.client.XmlRpcHttpClientConfig;
import org.apache.xmlrpc.client.XmlRpcTransport;
import org.apache.xmlrpc.client.XmlRpcTransportFactoryImpl;
import org.eclipse.mylar.tasks.ui.TasksUiPlugin;

/**
 * @author Steffen Pingel
 */
public class TracHttpClientTransportFactory extends XmlRpcTransportFactoryImpl {

	public static class TracHttpException extends XmlRpcException {

		private static final long serialVersionUID = 9032521978140685830L;

		public TracHttpException(int responseCode) {
			super(responseCode, "HTTP Error " + responseCode);
		}

	}

	/**
	 * A transport that uses the Apache HttpClient library. 
	 */
	public static class TracHttpClientTransport extends XmlRpcCommonsTransport {

		public TracHttpClientTransport(XmlRpcClient client) {
			super(client);

			Proxy proxySettings = TasksUiPlugin.getDefault().getProxySettings();
			if (proxySettings != null && proxySettings.address() instanceof InetSocketAddress) {
				InetSocketAddress address = (InetSocketAddress) proxySettings.address();
				getHttpClient().getHostConfiguration().setProxy(address.getHostName(), address.getPort());
			}

			XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) client.getConfig();
			// this needs to be set to avoid exceptions
			getHttpClient().getParams().setAuthenticationPreemptive(config.getBasicUserName() != null);
		}

		public HttpClient getHttpClient() {
			return (HttpClient) getValue("client");
		}

		@Override
		protected InputStream getInputStream() throws XmlRpcException {
			int responseCode = getMethod().getStatusCode();
			if (responseCode != HttpURLConnection.HTTP_OK) {
				throw new TracHttpException(responseCode);
			}

			return super.getInputStream();
		}

		public PostMethod getMethod() {
			return (PostMethod) getValue("method");
		}

		private Object getValue(String name) {
			try {
				Field field = XmlRpcCommonsTransport.class.getDeclaredField(name);
				field.setAccessible(true);
				return field.get(this);
			} catch (Throwable t) {
				throw new RuntimeException("Internal error accessing HttpClient", t);
			}
		}

	}

	private final TracHttpClientTransport transport;

	public TracHttpClientTransportFactory(XmlRpcClient client) {
		super(client);

		transport = new TracHttpClientTransport(client);
	}

	public XmlRpcTransport getTransport() {
		return transport;
	}
}

Lines 12-23 Link Here

(-)src/org/eclipse/mylar/trac/tests/TracXmlRpcClientTest.java (+24 lines)
12	package org.eclipse.mylar.trac.tests;	12	package org.eclipse.mylar.trac.tests;
13		13
14	import java.net.URL;	14	import java.net.URL;
		15	import java.util.Arrays;
		16	import java.util.Comparator;
		17	import java.util.Date;
15		18
		19	import org.eclipse.core.runtime.NullProgressMonitor;
16	import org.eclipse.mylar.internal.trac.core.ITracClient;	20	import org.eclipse.mylar.internal.trac.core.ITracClient;
17	import org.eclipse.mylar.internal.trac.core.TracLoginException;	21	import org.eclipse.mylar.internal.trac.core.TracLoginException;
18	import org.eclipse.mylar.internal.trac.core.TracRemoteException;	22	import org.eclipse.mylar.internal.trac.core.TracRemoteException;
19	import org.eclipse.mylar.internal.trac.core.TracXmlRpcClient;	23	import org.eclipse.mylar.internal.trac.core.TracXmlRpcClient;
20	import org.eclipse.mylar.internal.trac.core.ITracClient.Version;	24	import org.eclipse.mylar.internal.trac.core.ITracClient.Version;
		25	import org.eclipse.mylar.internal.trac.model.TracVersion;
21	import org.eclipse.mylar.trac.tests.support.AbstractTracRepositoryFactory;	26	import org.eclipse.mylar.trac.tests.support.AbstractTracRepositoryFactory;
22		27
23	/**	28	/**
Lines 51-54 Link Here
51	}	56	}
52	}	57	}
53		58
		59	public void testUpdateAttributes() throws Exception {
		60	factory.connectRepository1();
		61	assertNull(factory.repository.getMilestones());
		62	factory.repository.updateAttributes(new NullProgressMonitor());
		63	TracVersion[] versions = factory.repository.getVersions();
		64	assertEquals(2, versions.length);
		65	Arrays.sort(versions, new Comparator<TracVersion>() {
		66	public int compare(TracVersion o1, TracVersion o2) {
		67	return o1.getName().compareTo(o2.getName());
		68	}
		69	});
		70	assertEquals("v1", versions[0].getName());
		71	assertEquals("description1", versions[0].getDescription());
		72	assertEquals(new Date(86400 * 1000), versions[0].getTime());
		73	assertEquals("v2", versions[1].getName());
		74	assertEquals("description2", versions[1].getDescription());
		75	assertEquals(new Date(86400 * 2 * 1000), versions[1].getTime());
		76	}
		77
54	}	78	}

Lines 13-33 Link Here

(-)src/org/eclipse/mylar/trac/tests/TracXmlRpcTest.java (-108 / +91 lines)
13		13
14	import java.io.IOException;	14	import java.io.IOException;
15	import java.net.URL;	15	import java.net.URL;
		16	import java.util.ArrayList;
16	import java.util.Date;	17	import java.util.Date;
17	import java.util.Hashtable;	18	import java.util.Hashtable;
		19	import java.util.List;
		20	import java.util.Map;
18	import java.util.Random;	21	import java.util.Random;
19	import java.util.Vector;
20
21	import javax.net.ssl.HttpsURLConnection;
22	import javax.net.ssl.SSLContext;
23		22
24	import junit.framework.TestCase;	23	import junit.framework.TestCase;
25		24
26	import org.apache.xmlrpc.DefaultXmlRpcTransportFactory;
27	import org.apache.xmlrpc.XmlRpc;
28	import org.apache.xmlrpc.XmlRpcClient;
29	import org.apache.xmlrpc.XmlRpcException;	25	import org.apache.xmlrpc.XmlRpcException;
30	import org.eclipse.mylar.internal.trac.TrustAll;	26	import org.apache.xmlrpc.client.XmlRpcClient;
		27	import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;
		28	import org.eclipse.mylar.internal.trac.core.TracHttpClientTransportFactory;
31		29
32	/**	30	/**
33	* Test cases for <a href="http://trac-hacks.org/wiki/XmlRpcPlugin">Trac XML-RPC	31	* Test cases for <a href="http://trac-hacks.org/wiki/XmlRpcPlugin">Trac XML-RPC
Lines 55-87 Link Here
55		53
56	random = new Random();	54	random = new Random();
57		55
58	XmlRpc.setDefaultInputEncoding("UTF-8");
59
60	createConnection(new URL(Constants.TEST_REPOSITORY1_URL + XMLRPC_URL),	56	createConnection(new URL(Constants.TEST_REPOSITORY1_URL + XMLRPC_URL),
61	Constants.TEST_REPOSITORY1_ADMIN_USERNAME, Constants.TEST_REPOSITORY1_ADMIN_PASSWORD);	57	Constants.TEST_REPOSITORY1_ADMIN_USERNAME, Constants.TEST_REPOSITORY1_ADMIN_PASSWORD);
62	}	58	}
63		59
64	@SuppressWarnings("deprecation")	60	@SuppressWarnings("deprecation")
65	private void createConnection(URL url, String username, String password) throws Exception {	61	private void createConnection(URL url, String username, String password) throws Exception {
66	if (url.toString().startsWith("https")) {	62	XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
67	DefaultXmlRpcTransportFactory transport = new DefaultXmlRpcTransportFactory(url);	63	config.setEncoding("UTF-8");
68	transport.setBasicAuthentication(username, password);	64	config.setBasicUserName(username);
69		65	config.setBasicPassword(password);
70	SSLContext ctx = SSLContext.getInstance("TLS");	66	config.setServerURL(url);
71		67
72	javax.net.ssl.TrustManager[] tm = new javax.net.ssl.TrustManager[] { new TrustAll() };	68	xmlrpc = new XmlRpcClient();
73	ctx.init(null, tm, null);	69	xmlrpc.setConfig(config);
74	HttpsURLConnection.setDefaultSSLSocketFactory(ctx.getSocketFactory());	70
75		71	TracHttpClientTransportFactory factory = new TracHttpClientTransportFactory(xmlrpc);
76	xmlrpc = new XmlRpcClient(url, transport);	72	xmlrpc.setTransportFactory(factory);
77	} else {
78	xmlrpc = new XmlRpcClient(url);
79
80	// the XML-RPC library is kind of broken: setting authentication
81	// credentials for
82	// http connections is only possible through a deprecated method
83	xmlrpc.setBasicAuthentication(username, password);
84	}
85		73
86	this.username = username;	74	this.username = username;
87	// this.password = password;	75	// this.password = password;
Lines 92-112 Link Here
92	}	80	}
93		81
94	private Object call(String method, Object... parameters) throws XmlRpcException, IOException {	82	private Object call(String method, Object... parameters) throws XmlRpcException, IOException {
95	Vector<Object> params = new Vector<Object>();	83	Object result = xmlrpc.execute(method, parameters);
96	for (Object parameter : parameters) {
97	params.add(parameter);
98	}
99
100	Object result = xmlrpc.execute(method, params);
101	if (result instanceof XmlRpcException) {	84	if (result instanceof XmlRpcException) {
102	throw (XmlRpcException) result;	85	throw (XmlRpcException) result;
103	}	86	}
104	return result;	87	return result;
105	}	88	}
106		89
107	public Hashtable<String, Object> createMultiCall(String methodName, Object... parameters) throws XmlRpcException,	90	public Map<String, Object> createMultiCall(String methodName, Object... parameters) throws XmlRpcException,
108	IOException {	91	IOException {
109	Hashtable<String, Object> table = new Hashtable<String, Object>();	92	Map<String, Object> table = new Hashtable<String, Object>();
110	table.put("methodName", methodName);	93	table.put("methodName", methodName);
111	table.put("params", parameters);	94	table.put("params", parameters);
112	return table;	95	return table;
Lines 120-126 Link Here
120		103
121	call(module + ".create", "foo", "bar");	104	call(module + ".create", "foo", "bar");
122		105
123	assertHasValue(((Vector) call(module + ".getAll")).toArray(), "foo");	106	assertHasValue((Object[]) call(module + ".getAll"), "foo");
124	assertEquals("bar", (String) (call(module + ".get", "foo")));	107	assertEquals("bar", (String) (call(module + ".get", "foo")));
125		108
126	call(module + ".update", "foo", "baz");	109	call(module + ".update", "foo", "baz");
Lines 151-165 Link Here
151	} catch (XmlRpcException e) {	134	} catch (XmlRpcException e) {
152	}	135	}
153		136
154	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	137	Map<String, Object> attributes = new Hashtable<String, Object>();
155	for (int i = 0; i < fields.length; i += 2) {	138	for (int i = 0; i < fields.length; i += 2) {
156	attributes.put((String) fields[i], createValue(fields[i], fields[i + 1]));	139	attributes.put((String) fields[i], createValue(fields[i], fields[i + 1]));
157	}	140	}
158		141
159	call(module + ".create", "foo", attributes);	142	call(module + ".create", "foo", attributes);
160		143
161	assertHasValue(((Vector) call(module + ".getAll")).toArray(), "foo");	144	assertHasValue((Object[]) call(module + ".getAll"), "foo");
162	Hashtable values = (Hashtable) call(module + ".get", "foo");	145	Map values = (Map) call(module + ".get", "foo");
163	for (String attribute : attributes.keySet()) {	146	for (String attribute : attributes.keySet()) {
164	assertEquals(attributes.get(attribute), values.get(attribute));	147	assertEquals(attributes.get(attribute), values.get(attribute));
165	}	148	}
Lines 169-175 Link Here
169	}	152	}
170		153
171	call(module + ".update", "foo", attributes);	154	call(module + ".update", "foo", attributes);
172	values = (Hashtable) call(module + ".get", "foo");	155	values = (Map) call(module + ".get", "foo");
173	for (String attribute : attributes.keySet()) {	156	for (String attribute : attributes.keySet()) {
174	assertEquals(attributes.get(attribute), values.get(attribute));	157	assertEquals(attributes.get(attribute), values.get(attribute));
175	}	158	}
Lines 186-199 Link Here
186	int due = (int) (System.currentTimeMillis() / 1000) + 1000;	169	int due = (int) (System.currentTimeMillis() / 1000) + 1000;
187	int completed = (int) (System.currentTimeMillis() / 1000);	170	int completed = (int) (System.currentTimeMillis() / 1000);
188		171
189	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	172	Map<String, Object> attributes = new Hashtable<String, Object>();
190	attributes.put("description", "description");	173	attributes.put("description", "description");
191	attributes.put("due", due);	174	attributes.put("due", due);
192	attributes.put("completed", completed);	175	attributes.put("completed", completed);
193		176
194	call("ticket.milestone.create", "foo", attributes);	177	call("ticket.milestone.create", "foo", attributes);
195		178
196	Hashtable values = (Hashtable) call("ticket.milestone.get", "foo");	179	Map values = (Map) call("ticket.milestone.get", "foo");
197	assertEquals(new Integer(due), (Integer) values.get("due"));	180	assertEquals(new Integer(due), (Integer) values.get("due"));
198	assertEquals(new Integer(completed), (Integer) values.get("completed"));	181	assertEquals(new Integer(completed), (Integer) values.get("completed"));
199		182
Lines 209-236 Link Here
209	fail("Could not find expected value: " + value);	192	fail("Could not find expected value: " + value);
210	}	193	}
211		194
212	private void assertTicketHasAttributes(Hashtable<String, Object> attributes, int id, Vector ticket) {	195	private void assertTicketHasAttributes(Map<String, Object> attributes, int id, Object[] ticket) {
213	assertTicketHasAttributes(attributes, id, ticket, true);	196	assertTicketHasAttributes(attributes, id, ticket, true);
214	}	197	}
215		198
216	private void assertTicketHasAttributes(Hashtable<String, Object> attributes, int id, Vector ticket,	199	private void assertTicketHasAttributes(Map<String, Object> attributes, int id, Object[] ticket,
217	boolean newTicket) {	200	boolean newTicket) {
218	assertEquals(id, ticket.get(0));	201	assertEquals(id, ticket[0]);
219	assertTrue(ticket.get(1) instanceof Integer); // time created	202	assertTrue(ticket[1] instanceof Integer); // time created
220	// time changed	203	// time changed
221	if (newTicket) {	204	if (newTicket) {
222	assertEquals(ticket.get(1), ticket.get(2));	205	assertEquals(ticket[1], ticket[2]);
223	} else {	206	} else {
224	assertTrue((Integer) ticket.get(2) >= (Integer) ticket.get(1));	207	assertTrue((Integer) ticket[2] >= (Integer) ticket[1]);
225	}	208	}
226	Hashtable values = (Hashtable) ticket.get(3);	209	Map values = (Map) ticket[3];
227	for (String attribute : attributes.keySet()) {	210	for (String attribute : attributes.keySet()) {
228	assertEquals(attributes.get(attribute), values.get(attribute));	211	assertEquals(attributes.get(attribute), values.get(attribute));
229	}	212	}
230	}	213	}
231		214
232	public void testGetTicket() throws XmlRpcException, IOException {	215	public void testGetTicket() throws XmlRpcException, IOException {
233	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	216	Map<String, Object> attributes = new Hashtable<String, Object>();
234	attributes.put("type", "task");	217	attributes.put("type", "task");
235	attributes.put("status", "closed");	218	attributes.put("status", "closed");
236	int id = (Integer) call("ticket.create", "summary", "description", attributes);	219	int id = (Integer) call("ticket.create", "summary", "description", attributes);
Lines 238-244 Link Here
238	attributes.put("summary", "summary");	221	attributes.put("summary", "summary");
239	attributes.put("description", "description");	222	attributes.put("description", "description");
240		223
241	Vector ticket = (Vector) call("ticket.get", id);	224	Object[] ticket = (Object[]) call("ticket.get", id);
242	assertTicketHasAttributes(attributes, id, ticket);	225	assertTicketHasAttributes(attributes, id, ticket);
243		226
244	call("ticket.delete", id);	227	call("ticket.delete", id);
Lines 252-258 Link Here
252	}	235	}
253		236
254	try {	237	try {
255	Vector ticket = (Vector) call("ticket.get", Integer.MAX_VALUE);	238	List ticket = (List) call("ticket.get", Integer.MAX_VALUE);
256	fail("Expected XmlRpcException, got ticket instead: " + ticket);	239	fail("Expected XmlRpcException, got ticket instead: " + ticket);
257	} catch (XmlRpcException e) {	240	} catch (XmlRpcException e) {
258	// ignore	241	// ignore
Lines 260-272 Link Here
260	}	243	}
261		244
262	public void testGetTicketUmlaute() throws XmlRpcException, IOException {	245	public void testGetTicketUmlaute() throws XmlRpcException, IOException {
263	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	246	Map<String, Object> attributes = new Hashtable<String, Object>();
264	int id = (Integer) call("ticket.create", "summaryäÖÜ", "ßßß", attributes);	247	int id = (Integer) call("ticket.create", "summaryäÖÜ", "ßßß", attributes);
265		248
266	attributes.put("summary", "summaryäÖÜ");	249	attributes.put("summary", "summaryäÖÜ");
267	attributes.put("description", "ßßß");	250	attributes.put("description", "ßßß");
268		251
269	Vector ticket = (Vector) call("ticket.get", id);	252	Object[] ticket = (Object[]) call("ticket.get", id);
270	assertTicketHasAttributes(attributes, id, ticket);	253	assertTicketHasAttributes(attributes, id, ticket);
271		254
272	call("ticket.delete", id);	255	call("ticket.delete", id);
Lines 275-288 Link Here
275	public void testUpdateTicket() throws XmlRpcException, IOException {	258	public void testUpdateTicket() throws XmlRpcException, IOException {
276	int id = (Integer) call("ticket.create", "summary", "description", new Hashtable());	259	int id = (Integer) call("ticket.create", "summary", "description", new Hashtable());
277		260
278	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	261	Map<String, Object> attributes = new Hashtable<String, Object>();
279	attributes.put("summary", "changed");	262	attributes.put("summary", "changed");
280	call("ticket.update", id, "my comment", attributes);	263	call("ticket.update", id, "my comment", attributes);
281		264
282	attributes.put("description", "description");	265	attributes.put("description", "description");
283		266
284	Vector ticket = (Vector) call("ticket.get", id);	267	Object[] ticket = (Object[]) call("ticket.get", id);
285	Hashtable values = (Hashtable) ticket.get(3);	268	Map values = (Map) ticket[3];
286	for (String attribute : attributes.keySet()) {	269	for (String attribute : attributes.keySet()) {
287	assertEquals(attributes.get(attribute), values.get(attribute));	270	assertEquals(attributes.get(attribute), values.get(attribute));
288	}	271	}
Lines 291-297 Link Here
291	}	274	}
292		275
293	public void testTicketCustomFields() throws XmlRpcException, IOException {	276	public void testTicketCustomFields() throws XmlRpcException, IOException {
294	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	277	Map<String, Object> attributes = new Hashtable<String, Object>();
295	attributes.put("custom_text_field", "myvalue");	278	attributes.put("custom_text_field", "myvalue");
296	int id = (Integer) call("ticket.create", "summary", "description", attributes);	279	int id = (Integer) call("ticket.create", "summary", "description", attributes);
297		280
Lines 301-307 Link Here
301	attributes.put("custom_radio_field", "baz");	284	attributes.put("custom_radio_field", "baz");
302	attributes.put("custom_textarea_field", "default text");	285	attributes.put("custom_textarea_field", "default text");
303		286
304	Vector ticket = (Vector) call("ticket.get", id);	287	Object[] ticket = (Object[]) call("ticket.get", id);
305	assertTicketHasAttributes(attributes, id, ticket);	288	assertTicketHasAttributes(attributes, id, ticket);
306		289
307	attributes.put("custom_text_field", "myvalue2");	290	attributes.put("custom_text_field", "myvalue2");
Lines 312-318 Link Here
312		295
313	call("ticket.update", id, "my comment", attributes);	296	call("ticket.update", id, "my comment", attributes);
314		297
315	ticket = (Vector) call("ticket.get", id);	298	ticket = (Object[]) call("ticket.get", id);
316	assertTicketHasAttributes(attributes, id, ticket, false);	299	assertTicketHasAttributes(attributes, id, ticket, false);
317		300
318	call("ticket.delete", id);	301	call("ticket.delete", id);
Lines 321-337 Link Here
321	public void testGetChangeLog() throws XmlRpcException, IOException {	304	public void testGetChangeLog() throws XmlRpcException, IOException {
322	int id = (Integer) call("ticket.create", "summary", "description", new Hashtable());	305	int id = (Integer) call("ticket.create", "summary", "description", new Hashtable());
323		306
324	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	307	Map<String, Object> attributes = new Hashtable<String, Object>();
325	attributes.put("summary", "changed");	308	attributes.put("summary", "changed");
326	call("ticket.update", id, "my comment", attributes);	309	call("ticket.update", id, "my comment", attributes);
327		310
328	Vector log = (Vector) call("ticket.changeLog", id, 0);	311	Object[] log = (Object[]) call("ticket.changeLog", id, 0);
329	Vector entry = (Vector) log.get(0);	312	Object[] entry = (Object[]) log[0];
330	assertTrue(entry.get(0) instanceof Integer); // time	313	assertTrue(entry[0] instanceof Integer); // time
331	assertEquals(username, entry.get(1)); // author	314	assertEquals(username, entry[1]); // author
332	assertEquals("summary", entry.get(2)); // field	315	assertEquals("summary", entry[2]); // field
333	assertEquals("summary", entry.get(3)); // old value	316	assertEquals("summary", entry[3]); // old value
334	assertEquals("changed", entry.get(4)); // new value	317	assertEquals("changed", entry[4]); // new value
335		318
336	call("ticket.delete", id);	319	call("ticket.delete", id);
337	}	320	}
Lines 340-357 Link Here
340	int id1 = (Integer) call("ticket.create", "summary1", "description1", new Hashtable());	323	int id1 = (Integer) call("ticket.create", "summary1", "description1", new Hashtable());
341	int id2 = (Integer) call("ticket.create", "summary2", "description2", new Hashtable());	324	int id2 = (Integer) call("ticket.create", "summary2", "description2", new Hashtable());
342		325
343	Vector<Hashtable> calls = new Vector<Hashtable>();	326	List<Map> calls = new ArrayList<Map>();
344	calls.add(createMultiCall("ticket.get", id1));	327	calls.add(createMultiCall("ticket.get", id1));
345	calls.add(createMultiCall("ticket.get", id2));	328	calls.add(createMultiCall("ticket.get", id2));
346	Vector ret = (Vector) call("system.multicall", calls);	329	Object[] ret = (Object[]) call("system.multicall", calls);
347		330
348	Vector ticket = (Vector) ((Vector) ret.get(0)).get(0);	331	Object[] ticket = (Object[]) ((Object[]) ret[0])[0];
349	Hashtable<String, Object> attributes = new Hashtable<String, Object>();	332	Map<String, Object> attributes = new Hashtable<String, Object>();
350	attributes.put("summary", "summary1");	333	attributes.put("summary", "summary1");
351	attributes.put("description", "description1");	334	attributes.put("description", "description1");
352	assertTicketHasAttributes(attributes, id1, ticket);	335	assertTicketHasAttributes(attributes, id1, ticket);
353		336
354	ticket = (Vector) ((Vector) ret.get(1)).get(0);	337	ticket = (Object[]) ((Object[]) ret[1])[0];
355	attributes.clear();	338	attributes.clear();
356	attributes.put("summary", "summary2");	339	attributes.put("summary", "summary2");
357	attributes.put("description", "description2");	340	attributes.put("description", "description2");
Lines 369-377 Link Here
369	// attachment named "attach.txt"	352	// attachment named "attach.txt"
370	// assertEquals("attach.txt", filename);	353	// assertEquals("attach.txt", filename);
371		354
372	Vector ret = (Vector) call("ticket.listAttachments", id);	355	Object[] ret = (Object[]) call("ticket.listAttachments", id);
373	assertEquals(1, ret.size());	356	assertEquals(1, ret.length);
374	assertHasValue(ret.toArray(), filename);	357	assertHasValue(ret, filename);
375		358
376	byte[] bytes = (byte[]) call("ticket.getAttachment", id, filename);	359	byte[] bytes = (byte[]) call("ticket.getAttachment", id, filename);
377	String data = new String(bytes);	360	String data = new String(bytes);
Lines 379-394 Link Here
379		362
380	String filename2 = (String) call("ticket.putAttachment", id, filename, "data".getBytes(), true);	363	String filename2 = (String) call("ticket.putAttachment", id, filename, "data".getBytes(), true);
381	assertEquals(filename, filename2);	364	assertEquals(filename, filename2);
382	ret = (Vector) call("ticket.listAttachments", id);	365	ret = (Object[]) call("ticket.listAttachments", id);
383	assertEquals(1, ret.size());	366	assertEquals(1, ret.length);
384	assertHasValue(ret.toArray(), filename);	367	assertHasValue(ret, filename);
385		368
386	String filename3 = (String) call("ticket.putAttachment", id, "attach.txt", "data".getBytes(), false);	369	String filename3 = (String) call("ticket.putAttachment", id, "attach.txt", "data".getBytes(), false);
387	assertFalse("attach.txt".equals(filename3));	370	assertFalse("attach.txt".equals(filename3));
388	ret = (Vector) call("ticket.listAttachments", id);	371	ret = (Object[]) call("ticket.listAttachments", id);
389	assertEquals(2, ret.size());	372	assertEquals(2, ret.length);
390	assertHasValue(ret.toArray(), filename);	373	assertHasValue(ret, filename);
391	assertHasValue(ret.toArray(), filename3);	374	assertHasValue(ret, filename3);
392		375
393	call("ticket.delete", id);	376	call("ticket.delete", id);
394	}	377	}
Lines 398-417 Link Here
398		381
399	String filename = (String) call("ticket.putAttachment", id, "attach.txt", "data".getBytes(), true);	382	String filename = (String) call("ticket.putAttachment", id, "attach.txt", "data".getBytes(), true);
400		383
401	Vector ret = (Vector) call("ticket.listAttachments", id);	384	Object[] ret = (Object[]) call("ticket.listAttachments", id);
402	assertEquals(1, ret.size());	385	assertEquals(1, ret.length);
403	assertHasValue(ret.toArray(), filename);	386	assertHasValue(ret, filename);
404		387
405	call("ticket.deleteAttachment", id, filename);	388	call("ticket.deleteAttachment", id, filename);
406		389
407	ret = (Vector) call("ticket.listAttachments", id);	390	ret = (Object[]) call("ticket.listAttachments", id);
408	assertEquals(0, ret.size());	391	assertEquals(0, ret.length);
409		392
410	call("ticket.delete", id);	393	call("ticket.delete", id);
411	}	394	}
412		395
413	public void testQuery() throws XmlRpcException, IOException {	396	public void testQuery() throws XmlRpcException, IOException {
414	Vector ret = (Vector) call("ticket.query", "summary~=foo\|bar\|baz\|summary\|ticket");	397	Object[] ret = (Object[]) call("ticket.query", "summary~=foo\|bar\|baz\|summary\|ticket");
415	for (Object id : ret) {	398	for (Object id : ret) {
416	call("ticket.delete", (Integer) id);	399	call("ticket.delete", (Integer) id);
417	}	400	}
Lines 420-444 Link Here
420	int id2 = (Integer) call("ticket.create", "foobaz summary2", "description", new Hashtable());	403	int id2 = (Integer) call("ticket.create", "foobaz summary2", "description", new Hashtable());
421	int id3 = (Integer) call("ticket.create", "ticket3", "description3", new Hashtable());	404	int id3 = (Integer) call("ticket.create", "ticket3", "description3", new Hashtable());
422		405
423	ret = (Vector) call("ticket.query", "summary=foobarsummary1\|foobaz summary2");	406	ret = (Object[]) call("ticket.query", "summary=foobarsummary1\|foobaz summary2");
424	assertEquals(2, ret.size());	407	assertEquals(2, ret.length);
425	assertEquals(ret.get(0), id1);	408	assertEquals(id1, ret[0]);
426	assertEquals(ret.get(1), id2);	409	assertEquals(id2, ret[1]);
427		410
428	ret = (Vector) call("ticket.query", "summary~=fooba&summary~=summary");	411	ret = (Object[]) call("ticket.query", "summary~=fooba&summary~=summary");
429	assertEquals(2, ret.size());	412	assertEquals(2, ret.length);
430	assertEquals(ret.get(0), id1);	413	assertEquals(id1, ret[0]);
431	assertEquals(ret.get(1), id2);	414	assertEquals(id2, ret[1]);
432		415
433	// ret = (Vector) call("ticket.query", "summary~=bar&summary~=baz");	416	// ret = (Vector) call("ticket.query", "summary~=bar&summary~=baz");
434	// assertEquals(0, ret.size());	417	// assertEquals(0, ret.size());
435		418
436	ret = (Vector) call("ticket.query", "summary~=bar\|baz");	419	ret = (Object[]) call("ticket.query", "summary~=bar\|baz");
437	assertEquals(2, ret.size());	420	assertEquals(2, ret.length);
438		421
439	ret = (Vector) call("ticket.query", "description~=description3");	422	ret = (Object[]) call("ticket.query", "description~=description3");
440	assertEquals(1, ret.size());	423	assertEquals(1, ret.length);
441	assertEquals(ret.get(0), id3);	424	assertEquals(id3, ret[0]);
442		425
443	call("ticket.delete", id1);	426	call("ticket.delete", id1);
444	call("ticket.delete", id2);	427	call("ticket.delete", id2);
Lines 448-456 Link Here
448	public void testQueryAll() throws XmlRpcException, IOException {	431	public void testQueryAll() throws XmlRpcException, IOException {
449	int id = (Integer) call("ticket.create", "foo", "description", new Hashtable());	432	int id = (Integer) call("ticket.create", "foo", "description", new Hashtable());
450		433
451	Vector ret = (Vector) call("ticket.query", "order=id");	434	Object[] ret = (Object[]) call("ticket.query", "order=id");
452	assertTrue(ret.size() > 0);	435	assertTrue(ret.length > 0);
453	assertHasValue(ret.toArray(), id);	436	assertHasValue(ret, id);
454		437
455	call("ticket.delete", id);	438	call("ticket.delete", id);
456	}	439	}

Lines 12-18 Link Here

(-)src/org/eclipse/mylar/trac/tests/AbstractTracClientSearchTest.java (-2 / +1 lines)
12	package org.eclipse.mylar.trac.tests;	12	package org.eclipse.mylar.trac.tests;
13		13
14	import java.util.ArrayList;	14	import java.util.ArrayList;
15	import java.util.Hashtable;
16	import java.util.List;	15	import java.util.List;
17	import java.util.Map;	16	import java.util.Map;
18		17
Lines 61-67 Link Here
61	protected void assertTicketEquals(Ticket ticket, TracTicket tracTicket) throws Exception {	60	protected void assertTicketEquals(Ticket ticket, TracTicket tracTicket) throws Exception {
62	assertTrue(tracTicket.isValid());	61	assertTrue(tracTicket.isValid());
63		62
64	Hashtable expectedValues = ticket.getValues();	63	Map expectedValues = ticket.getValues();
65	Map<String, String> values = tracTicket.getValues();	64	Map<String, String> values = tracTicket.getValues();
66	for (String key : values.keySet()) {	65	for (String key : values.keySet()) {
67	assertEquals("Values for key '" + key + "' did not match", expectedValues.get(key), values.get(key));	66	assertEquals("Values for key '" + key + "' did not match", expectedValues.get(key), values.get(key));

Lines 12-21 Link Here

(-)src/org/eclipse/mylar/trac/tests/Trac09ClientTest.java (+20 lines)
12	package org.eclipse.mylar.trac.tests;	12	package org.eclipse.mylar.trac.tests;
13		13
14	import java.net.URL;	14	import java.net.URL;
		15	import java.util.Arrays;
		16	import java.util.Comparator;
15		17
		18	import org.eclipse.core.runtime.NullProgressMonitor;
16	import org.eclipse.mylar.internal.trac.core.ITracClient;	19	import org.eclipse.mylar.internal.trac.core.ITracClient;
17	import org.eclipse.mylar.internal.trac.core.Trac09Client;	20	import org.eclipse.mylar.internal.trac.core.Trac09Client;
18	import org.eclipse.mylar.internal.trac.core.ITracClient.Version;	21	import org.eclipse.mylar.internal.trac.core.ITracClient.Version;
		22	import org.eclipse.mylar.internal.trac.model.TracVersion;
19	import org.eclipse.mylar.trac.tests.support.AbstractTracRepositoryFactory;	23	import org.eclipse.mylar.trac.tests.support.AbstractTracRepositoryFactory;
20		24
21	/**	25	/**
Lines 36-39 Link Here
36	factory.repository.validate();	40	factory.repository.validate();
37	}	41	}
38		42
		43	public void testUpdateAttributes() throws Exception {
		44	factory.connectRepository1();
		45	assertNull(factory.repository.getMilestones());
		46	factory.repository.updateAttributes(new NullProgressMonitor());
		47	TracVersion[] versions = factory.repository.getVersions();
		48	assertEquals(2, versions.length);
		49	Arrays.sort(versions, new Comparator<TracVersion>() {
		50	public int compare(TracVersion o1, TracVersion o2) {
		51	return o1.getName().compareTo(o2.getName());
		52	}
		53	});
		54	assertEquals("v1", versions[0].getName());
		55	assertEquals("v2", versions[1].getName());
		56	}
		57
		58
39	}	59	}





	public static Test suite() {
		TestSuite suite = new TestSuite("Test for org.eclipse.mylar.trac.tests");
		// $JUnit-BEGIN$
		// suite.addTestSuite(TracXmlRpcTest.class);
		suite.addTestSuite(TracSearchTest.class);
		suite.addTestSuite(TracTicketTest.class);
		suite.addTestSuite(TracXmlRpcClientTest.class);

		suite.addTestSuite(TracClientFactoryTest.class);
		suite.addTestSuite(TracRepositoryConnectorTest.class);
		suite.addTestSuite(TracQueryTest.class);
		suite.addTestSuite(TracRepositoryQueryTest.class);
		// $JUnit-END$
		return suite;
	}


Lines 11-16 Link Here

(-)src/org/eclipse/mylar/trac/tests/TracClientFactoryTest.java (+10 lines)
11		11
12	package org.eclipse.mylar.trac.tests;	12	package org.eclipse.mylar.trac.tests;
13		13
		14	import java.net.Authenticator;
		15
14	import junit.framework.TestCase;	16	import junit.framework.TestCase;
15		17
16	import org.eclipse.mylar.internal.trac.core.ITracClient;	18	import org.eclipse.mylar.internal.trac.core.ITracClient;
Lines 26-31 Link Here
26	*/	28	*/
27	public class TracClientFactoryTest extends TestCase {	29	public class TracClientFactoryTest extends TestCase {
28		30
		31	@Override
		32	protected void setUp() throws Exception {
		33	super.setUp();
		34
		35	// make sure no dialog pops up to prompt for a password
		36	Authenticator.setDefault(null);
		37	}
		38
29	public void testCreateClient() throws Exception {	39	public void testCreateClient() throws Exception {
30	ITracClient client = TracClientFactory.createClient(Constants.TEST_REPOSITORY1_URL, Version.TRAC_0_9, "user",	40	ITracClient client = TracClientFactory.createClient(Constants.TEST_REPOSITORY1_URL, Version.TRAC_0_9, "user",
31	"password");	41	"password");

Lines 7-13 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
7	Require-Bundle: org.junit,	7	Require-Bundle: org.junit,
8	org.eclipse.ui,	8	org.eclipse.ui,
9	org.eclipse.core.runtime,	9	org.eclipse.core.runtime,
10	org.apache.xmlrpc,	10	org.eclipse.mylar.context.core,
11	org.eclipse.mylar.tasks.ui,	11	org.eclipse.mylar.tasks.ui,
12	org.eclipse.mylar.trac,	12	org.eclipse.mylar.trac,
13	org.eclipse.mylar.tasks.core	13	org.eclipse.mylar.tasks.core




import java.util.Arrays;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import org.apache.xmlrpc.XmlRpcClient;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.eclipse.mylar.internal.trac.core.TracXmlRpcClient;
import org.eclipse.mylar.internal.trac.core.ITracClient.Version;


		}

		public ModelEnum deleteAndCreate(Object... params) throws Exception {
			if (Arrays.asList(getAll()).contains(id)) {
				delete();
					delete();
				}
			} catch (Exception e) {
				// ignore
			}

			return create(params);


		@SuppressWarnings("unchecked")
		public String[] getAll() throws Exception {
			return Arrays.asList((Object[]) call(module + ".getAll")).toArray(new String[0]);
		}

		private Hashtable<String, Object> toMap(Object... params) {

			return getValues().get(key);
		}

		public Map getValues() throws Exception {
			return (Map) ((Object[]) call("ticket.get", id))[3];
		}

		@SuppressWarnings("unchecked")
		public Integer[] getAll() throws Exception {
			return Arrays.asList((Object[]) call("ticket.query", "order=id")).toArray(new Integer[0]);
		}

		public int getId() {

		}

		public TicketEnum deleteAndCreate(String param) throws Exception {
			if (Arrays.asList(getAll()).contains(id)) {
				delete();
					delete();
				}
			} catch (Exception e) {
				// ignore
			}

			return create(param);


		@SuppressWarnings("unchecked")
		public String[] getAll() throws Exception {
			return Arrays.asList((Object[]) call(module + ".getAll")).toArray(new String[0]);
		}

		public TicketEnum update(String param) throws Exception {

Lines 30-35 Link Here

(-)src/org/eclipse/mylar/trac/tests/support/TestFixture.java (+4 lines)
30	XmlRpcServer server = new XmlRpcServer(Constants.TEST_REPOSITORY1_URL,	30	XmlRpcServer server = new XmlRpcServer(Constants.TEST_REPOSITORY1_URL,
31	Constants.TEST_REPOSITORY1_ADMIN_USERNAME, Constants.TEST_REPOSITORY1_ADMIN_PASSWORD);	31	Constants.TEST_REPOSITORY1_ADMIN_USERNAME, Constants.TEST_REPOSITORY1_ADMIN_PASSWORD);
32		32
		33	server.ticketVersion(null).deleteAll();
		34	server.ticketVersion("v1").create(86400, "description1");
		35	server.ticketVersion("v2").create(86400 * 2, "description2");
		36
33	server.ticket().deleteAll();	37	server.ticket().deleteAll();
34		38
35	server.ticketMilestone("m1").deleteAndCreate();	39	server.ticketMilestone("m1").deleteAndCreate();




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.trac.tests;

import java.util.Arrays;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.mylar.internal.trac.TracRepositoryQuery;
import org.eclipse.mylar.internal.trac.core.ITracClient;
import org.eclipse.mylar.internal.trac.model.TracSearch;
import org.eclipse.mylar.internal.trac.model.TracSearchFilter;

public class TracRepositoryQueryTest extends TestCase {

	public void testGetFilterList() {
		String repositoryUrl = "https://foo.bar/repo";
		String parameterUrl = "&status=new&status=assigned&status=reopened&milestone=0.1";
		String queryUrl = repositoryUrl + ITracClient.QUERY_URL + parameterUrl;
		TracRepositoryQuery query = new TracRepositoryQuery(repositoryUrl, queryUrl, "description", null);

		TracSearch filterList = query.getTracSearch();

		assertEquals(parameterUrl, filterList.toUrl());
		assertEquals("&status=new|assigned|reopened&milestone=0.1", filterList.toQuery());

		List<TracSearchFilter> list = filterList.getFilters();
		TracSearchFilter filter = list.get(0);
		assertEquals("status", filter.getFieldName());
		assertEquals(Arrays.asList("new", "assigned", "reopened"), filter.getValues());
		filter = list.get(1);
		assertEquals("milestone", filter.getFieldName());
		assertEquals(Arrays.asList("0.1"), filter.getValues());
	}

}

Return to bug 151896

Lines 23-30 Link Here

(-)src/org/eclipse/mylar/internal/trac/MylarTracPlugin.java (+11 lines)
23	import javax.net.ssl.HttpsURLConnection;	23	import javax.net.ssl.HttpsURLConnection;
24	import javax.net.ssl.SSLContext;	24	import javax.net.ssl.SSLContext;
25		25
		26	import org.apache.commons.httpclient.protocol.Protocol;
26	import org.eclipse.jface.dialogs.MessageDialog;	27	import org.eclipse.jface.dialogs.MessageDialog;
27	import org.eclipse.mylar.context.core.MylarStatusHandler;	28	import org.eclipse.mylar.context.core.MylarStatusHandler;
		29	import org.eclipse.mylar.internal.tasks.core.SslProtocolSocketFactory;
28	import org.eclipse.mylar.internal.tasks.ui.views.TaskRepositoriesView;	30	import org.eclipse.mylar.internal.tasks.ui.views.TaskRepositoriesView;
29	import org.eclipse.mylar.internal.trac.core.TracException;	31	import org.eclipse.mylar.internal.trac.core.TracException;
30	import org.eclipse.mylar.internal.trac.core.TracLoginException;	32	import org.eclipse.mylar.internal.trac.core.TracLoginException;
Lines 54-59 Link Here
54		56
55	public void start(BundleContext context) throws Exception {	57	public void start(BundleContext context) throws Exception {
56	super.start(context);	58	super.start(context);
		59
		60	// TODO the protocol configuration of HttpClient should not be registered globally
		61	Protocol acceptAllSsl = new Protocol("https", new SslProtocolSocketFactory(), 443);
		62	Protocol.registerProtocol("https", acceptAllSsl);
		63
		64	// TODO the logging configuration of HttpClient should be done elsewhere
		65	System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
		66	System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire.header", "off");
		67	System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.commons.httpclient", "off");
57	}	68	}
58		69
59	public void stop(BundleContext context) throws Exception {	70	public void stop(BundleContext context) throws Exception {

Added Link Here

(-)src/org/eclipse/mylar/internal/trac/core/TracHttpClientTransportFactory.java (+105 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Mylar project committers - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.trac.core;
13
14	import java.io.InputStream;
15	import java.lang.reflect.Field;
16	import java.net.HttpURLConnection;
17	import java.net.InetSocketAddress;
18	import java.net.Proxy;
19
20	import org.apache.commons.httpclient.HttpClient;
21	import org.apache.commons.httpclient.methods.PostMethod;
22	import org.apache.xmlrpc.XmlRpcException;
23	import org.apache.xmlrpc.client.XmlRpcClient;
24	import org.apache.xmlrpc.client.XmlRpcCommonsTransport;
25	import org.apache.xmlrpc.client.XmlRpcHttpClientConfig;
26	import org.apache.xmlrpc.client.XmlRpcTransport;
27	import org.apache.xmlrpc.client.XmlRpcTransportFactoryImpl;
28	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
29
30	/**
31	* @author Steffen Pingel
32	*/
33	public class TracHttpClientTransportFactory extends XmlRpcTransportFactoryImpl {
34
35	public static class TracHttpException extends XmlRpcException {
36
37	private static final long serialVersionUID = 9032521978140685830L;
38
39	public TracHttpException(int responseCode) {
40	super(responseCode, "HTTP Error " + responseCode);
41	}
42
43	}
44
45	/**
46	* A transport that uses the Apache HttpClient library.
47	*/
48	public static class TracHttpClientTransport extends XmlRpcCommonsTransport {
49
50	public TracHttpClientTransport(XmlRpcClient client) {
51	super(client);
52
53	Proxy proxySettings = TasksUiPlugin.getDefault().getProxySettings();
54	if (proxySettings != null && proxySettings.address() instanceof InetSocketAddress) {
55	InetSocketAddress address = (InetSocketAddress) proxySettings.address();
56	getHttpClient().getHostConfiguration().setProxy(address.getHostName(), address.getPort());
57	}
58
59	XmlRpcHttpClientConfig config = (XmlRpcHttpClientConfig) client.getConfig();
60	// this needs to be set to avoid exceptions
61	getHttpClient().getParams().setAuthenticationPreemptive(config.getBasicUserName() != null);
62	}
63
64	public HttpClient getHttpClient() {
65	return (HttpClient) getValue("client");
66	}
67
68	@Override
69	protected InputStream getInputStream() throws XmlRpcException {
70	int responseCode = getMethod().getStatusCode();
71	if (responseCode != HttpURLConnection.HTTP_OK) {
72	throw new TracHttpException(responseCode);
73	}
74
75	return super.getInputStream();
76	}
77
78	public PostMethod getMethod() {
79	return (PostMethod) getValue("method");
80	}
81
82	private Object getValue(String name) {
83	try {
84	Field field = XmlRpcCommonsTransport.class.getDeclaredField(name);
85	field.setAccessible(true);
86	return field.get(this);
87	} catch (Throwable t) {
88	throw new RuntimeException("Internal error accessing HttpClient", t);
89	}
90	}
91
92	}
93
94	private final TracHttpClientTransport transport;
95
96	public TracHttpClientTransportFactory(XmlRpcClient client) {
97	super(client);
98
99	transport = new TracHttpClientTransport(client);
100	}
101
102	public XmlRpcTransport getTransport() {
103	return transport;
104	}
105	}

Lines 22-29 Link Here

(-)src/org/eclipse/mylar/trac/tests/AllTracTests.java (-3 / +4 lines)
22		22
23	public static Test suite() {	23	public static Test suite() {
24	TestSuite suite = new TestSuite("Test for org.eclipse.mylar.trac.tests");	24	TestSuite suite = new TestSuite("Test for org.eclipse.mylar.trac.tests");
25	//$JUnit-BEGIN$	25	// $JUnit-BEGIN$
26	suite.addTestSuite(TracXmlRpcTest.class);	26	// suite.addTestSuite(TracXmlRpcTest.class);
27	suite.addTestSuite(TracSearchTest.class);	27	suite.addTestSuite(TracSearchTest.class);
28	suite.addTestSuite(TracTicketTest.class);	28	suite.addTestSuite(TracTicketTest.class);
29	suite.addTestSuite(TracXmlRpcClientTest.class);	29	suite.addTestSuite(TracXmlRpcClientTest.class);
Lines 33-39 Link Here
33	suite.addTestSuite(TracClientFactoryTest.class);	33	suite.addTestSuite(TracClientFactoryTest.class);
34	suite.addTestSuite(TracRepositoryConnectorTest.class);	34	suite.addTestSuite(TracRepositoryConnectorTest.class);
35	suite.addTestSuite(TracQueryTest.class);	35	suite.addTestSuite(TracQueryTest.class);
36	//$JUnit-END$	36	suite.addTestSuite(TracRepositoryQueryTest.class);
		37	// $JUnit-END$
37	return suite;	38	return suite;
38	}	39	}
39		40