Attachment #74311 for bug #189518

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





import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;

			dest.mkdir();
		}
		assertTrue(dest.exists());
		TasksUiPlugin.getSynchronizationManager().setForceSyncExec(true);
	}

	@Override

		removeFiles(dest);
		dest.delete();
		assertFalse(dest.exists());
		TasksUiPlugin.getSynchronizationManager().setForceSyncExec(false);
	}
	
	public void testExportImportQuery() {

		externalizers.add(new MockTaskListFactory());
		TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);

		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		
		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query 2");
		queries.add(query1);
		queries.add(query2);

		File outFile = new File(dest, "test-query.xml.zip");
		
		TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQueries(queries, outFile);
		assertTrue(outFile.exists());
		
		TaskList taskList = TasksUiPlugin.getTaskListManager().resetTaskList();

		File inFile = new File(dest, "test-query.xml.zip");
		List<AbstractRepositoryQuery> resultQueries = TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(
				inFile);		
		assertEquals("2 Queries is imported", 2, resultQueries.size());
	}
	
	public void testImportedQueriesNameConflictResolving1() {
		// prepare for test
		TasksUiPlugin.getTaskListManager().resetTaskList();
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		
		// create test data
		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		
		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		query1.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query");
		query2.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query3 = new MockRepositoryQuery("Test Query");
		query3.setRepositoryUrl(repository.getUrl());
		
		queries.add(query1);
		queries.add(query2);
		queries.add(query3);
		
		// run tested functionality
		TasksUiPlugin.getTaskListManager().insertQueries(queries);
		
		// extract results
		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		for (AbstractRepositoryQuery query : queriesSet) {
			queriesMap.put(query.getHandleIdentifier(), query);
		}
		
		// check that the actual result is correct
		assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
		assertTrue("'Test Query[1]' query inserted", queriesMap.containsKey("Test Query[1]"));
		assertTrue("'Test Query[2]' query inserted", queriesMap.containsKey("Test Query[2]"));
	}
	

	public void testImportedQueriesNameConflictResolving2() {
		// prepare for test
		TasksUiPlugin.getTaskListManager().resetTaskList();
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		
		// create test data
		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		
		MockRepositoryQuery query1 = new MockRepositoryQuery("Test2");
		query1.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query2 = new MockRepositoryQuery("Test2[1]");
		query2.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query3 = new MockRepositoryQuery("Test2");
		query3.setRepositoryUrl(repository.getUrl());
		
		queries.add(query1);
		queries.add(query2);
		queries.add(query3);
		
		// run tested functionality
		TasksUiPlugin.getTaskListManager().insertQueries(queries);
		
		// extract results
		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		for (AbstractRepositoryQuery query : queriesSet) {
			queriesMap.put(query.getHandleIdentifier(), query);
		}
		
		// check that the actual result is correct
		assertTrue("'Test2' query inserted", queriesMap.containsKey("Test2"));
		assertTrue("'Test2[1]' query inserted", queriesMap.containsKey("Test2[1]"));
		assertTrue("'Test2[2]' query inserted", queriesMap.containsKey("Test2[2]"));
		
	}
	

	public void testImportedBadQueriesNameConflictResolving() {
		// prepare for test
		TasksUiPlugin.getTaskListManager().resetTaskList();
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		
		// create test data
		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		
		MockRepositoryQuery query1 = new MockRepositoryQuery("Test[-10]");
		query1.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query2 = new MockRepositoryQuery("Test[ABC]");
		query2.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query3 = new MockRepositoryQuery("Test[1]");
		query3.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query4 = new MockRepositoryQuery("Test");
		query4.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query5 = new MockRepositoryQuery("Test");
		query5.setRepositoryUrl(repository.getUrl());
		
		queries.add(query1);
		queries.add(query2);
		queries.add(query3);
		queries.add(query4);
		queries.add(query5);
		
		// run tested functionality
		TasksUiPlugin.getTaskListManager().insertQueries(queries);
		
		// extract results
		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		for (AbstractRepositoryQuery query : queriesSet) {
			queriesMap.put(query.getHandleIdentifier(), query);
		}
		
		// check that the actual result is correct
		assertTrue("'Test[-10]' query inserted", queriesMap.containsKey("Test[-10]"));
		assertTrue("'Test[ABC]' query inserted", queriesMap.containsKey("Test[ABC]"));
		assertTrue("'Test[1]' query inserted", queriesMap.containsKey("Test[1]"));
		assertTrue("'Test' query inserted", queriesMap.containsKey("Test"));
		assertTrue("Another 'Test' query inserted", queriesMap.containsKey("Test[2]"));
	}
	
	public void testImportedBadQueries() {
		// prepare for test
		TasksUiPlugin.getTaskListManager().resetTaskList();
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		
		// create test data
		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		
		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		query1.setRepositoryUrl(repository.getUrl());
		MockRepositoryQuery query2 = new MockRepositoryQuery("Bad Query");
		query2.setRepositoryUrl("bad url");
		
		queries.add(query1);
		queries.add(query2);
		
		// run tested functionality
		List<AbstractRepositoryQuery> badQueries = TasksUiPlugin.getTaskListManager().insertQueries(queries);
		
		// extract results
		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		for (AbstractRepositoryQuery query : queriesSet) {
			queriesMap.put(query.getHandleIdentifier(), query);
		}
		
		// check that the actual result is correct
		assertEquals("There is a bad query", 1, badQueries.size());
		assertEquals(query2, badQueries.get(0));
		assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
	}
	
	
	private void removeFiles(File root) {
		if (root.isDirectory()) {
			for (File file : root.listFiles()) {

Lines 57-62 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java (-42 / +79 lines)
57	* @author Mik Kersten	57	* @author Mik Kersten
58	* @author Ken Sueda	58	* @author Ken Sueda
59	* @author Rob Elves	59	* @author Rob Elves
		60	* @author Jevgeni Holodkov
60	*	61	*
61	* TODO: move to core?	62	* TODO: move to core?
62	*/	63	*/
Lines 338-345 Link Here
338	}	339	}
339	}	340	}
340		341
341	private void readQuery(TaskList taskList, Node child) {	342	/**
342	boolean wasRead = false;	343	* Reads the Query from the specified Node. If taskList is not null, then also adds this query to the TaskList
		344	*/
		345	private AbstractRepositoryQuery readQuery(TaskList taskList, Node child) {
		346	AbstractRepositoryQuery query = null;
343	for (AbstractTaskListFactory externalizer : externalizers) {	347	for (AbstractTaskListFactory externalizer : externalizers) {
344	Set<String> queryTagNames = externalizer.getQueryElementNames();	348	Set<String> queryTagNames = externalizer.getQueryElementNames();
345	if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {	349	if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
Lines 355-386 Link Here
355	label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);	359	label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
356	}	360	}
357		361
358	AbstractRepositoryQuery query = externalizer.createQuery(repositoryUrl,	362	query = externalizer.createQuery(repositoryUrl, queryString, label, childElement);
359	queryString, label, childElement);
360	if (query != null) {	363	if (query != null) {
361	wasRead = true;
362	if (childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH) != null	364	if (childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH) != null
363	&& !childElement.getAttribute(	365	&& !childElement.getAttribute(
364	DelegatingTaskExternalizer.KEY_LAST_REFRESH).equals("")) {	366	DelegatingTaskExternalizer.KEY_LAST_REFRESH).equals("")) {
365	query.setLastSynchronizedStamp(childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH));	367	query.setLastSynchronizedStamp(childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH));
366	}	368	}
367	taskList.internalAddQuery(query);
368	}	369	}
369	NodeList queryChildren = child.getChildNodes();	370
370	for (int ii = 0; ii < queryChildren.getLength(); ii++) {	371	// add created Query to the TaskList and read QueryHits (Tasks related to the Query)
371	Node queryNode = queryChildren.item(ii);	372	if (taskList != null) {
372	try {	373	if (query != null) {
373	delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);	374	taskList.internalAddQuery(query);
374	} catch (TaskExternalizationException e) {	375	}
375	hasCaughtException = true;	376
		377	NodeList queryChildren = child.getChildNodes();
		378	for (int ii = 0; ii < queryChildren.getLength(); ii++) {
		379	Node queryNode = queryChildren.item(ii);
		380	try {
		381	delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);
		382	} catch (TaskExternalizationException e) {
		383	hasCaughtException = true;
		384	}
376	}	385	}
377	}	386	}
		387
		388
378	break;	389	break;
379	}	390	}
380	}	391	}
381	if (!wasRead) {	392	if (query == null) {
382	orphanedQueryNodes.add(child);	393	orphanedQueryNodes.add(child);
383	}	394	}
		395
		396	return query;
384	}	397	}
385		398
386	/**	399	/**
Lines 480-486 Link Here
480	return externalizers;	493	return externalizers;
481	}	494	}
482		495
483	public void writeQuery(AbstractRepositoryQuery query, File outFile) {	496	public void writeQueries(List<AbstractRepositoryQuery> queries, File outFile) {
		497	Document doc = createQueryDocument(queries);
		498	if (doc != null) {
		499	writeDOMtoFile(doc, outFile);
		500	}
		501	return;
		502	}
		503
		504	/**
		505	* @return null if it was not possible to create the Query document.
		506	*/
		507	public Document createQueryDocument(List<AbstractRepositoryQuery> queries) {
484	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();	508	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
485	DocumentBuilder db;	509	DocumentBuilder db;
486	Document doc = null;	510	Document doc = null;
Lines 490-548 Link Here
490	doc = db.newDocument();	514	doc = db.newDocument();
491	} catch (ParserConfigurationException e) {	515	} catch (ParserConfigurationException e) {
492	StatusHandler.log(e, "could not create document");	516	StatusHandler.log(e, "could not create document");
493	return;	517	return null;
494	}	518	}
495		519
496	Element root = doc.createElement(ELEMENT_TASK_LIST);	520	Element root = doc.createElement(ELEMENT_TASK_LIST);
497	root.setAttribute(ATTRIBUTE_VERSION, VALUE_VERSION);	521	root.setAttribute(ATTRIBUTE_VERSION, VALUE_VERSION);
498		522
		523	for (AbstractRepositoryQuery query : queries) {
499	try {	524	try {
500	delagatingExternalizer.createQueryElement(query, doc, root);	525	delagatingExternalizer.createQueryElement(query, doc, root);
501	} catch (Throwable t) {	526	} catch (Throwable t) {
502	StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);	527	StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);
		528	return null;
503	}	529	}
		530	}
504		531
505	doc.appendChild(root);	532	doc.appendChild(root);
506	writeDOMtoFile(doc, outFile);	533	return doc;
507	return;
508	}	534	}
509		535
510	public void readQueries(TaskList taskList, File inFile) {	536	public List<AbstractRepositoryQuery> readQueries(File inFile) {
		537	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
511	try {	538	try {
512	if (!inFile.exists())	539	if (!inFile.exists())
513	return;	540	return queries;
514	Document doc = openAsDOM(inFile);	541	Document doc = openAsDOM(inFile);
515	if (doc == null) {	542	if (doc == null) {
516	handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));	543	handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));
517	return;	544	return queries;
518	}	545	}
519	Element root = doc.getDocumentElement();	546	queries = readQueryDocument(doc);
520	readVersion = root.getAttribute(ATTRIBUTE_VERSION);	547	} catch (Exception e) {
521		548	handleException(inFile, null, e);
522	if (!readVersion.equals(VALUE_VERSION_1_0_0)) {	549	}
523	NodeList list = root.getChildNodes();	550
		551	return queries;
		552	}
524		553
525	// read queries	554	/**
526	for (int i = 0; i < list.getLength(); i++) {	555	* @param Query document to read.
527	Node child = list.item(i);	556	*/
528	try {	557	public List<AbstractRepositoryQuery> readQueryDocument(Document doc) {
529	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {	558	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
530	readQuery(taskList, child);	559	Element root = doc.getDocumentElement();
		560	readVersion = root.getAttribute(ATTRIBUTE_VERSION);
		561
		562	if (!readVersion.equals(VALUE_VERSION_1_0_0)) {
		563	NodeList list = root.getChildNodes();
		564
		565	// read queries
		566	for (int i = 0; i < list.getLength(); i++) {
		567	Node child = list.item(i);
		568	try {
		569	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
		570	AbstractRepositoryQuery query = readQuery(null, child);
		571	if (query != null) {
		572	queries.add(query);
531	}	573	}
532	} catch (Exception e) {
533	handleException(inFile, child, e);
534	}	574	}
		575	} catch (Exception e) {
		576	StatusHandler.log(e, "Tasks may have been lost from " + child.getNodeName());
535	}	577	}
536	} else {
537	StatusHandler.log("version: " + readVersion + " not supported", this);
538	}	578	}
539	} catch (Exception e) {	579	} else {
540	handleException(inFile, null, e);	580	StatusHandler.log("version: " + readVersion + " not supported", this);
541	}	581	}
542		582
543	if (!hasCaughtException) {	583	return queries;
544	// save new task list only if there were no exception!
545	writeTaskList(taskList, inFile);
546	}
547	}	584	}
548	}	585	}

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TaskListManager.java (+68 lines)
14	import java.util.Calendar;	14	import java.util.Calendar;
15	import java.util.Date;	15	import java.util.Date;
16	import java.util.GregorianCalendar;	16	import java.util.GregorianCalendar;
		17	import java.util.HashMap;
17	import java.util.HashSet;	18	import java.util.HashSet;
18	import java.util.List;	19	import java.util.List;
19	import java.util.Map;	20	import java.util.Map;
Lines 21-26 Link Here
21	import java.util.Timer;	22	import java.util.Timer;
22	import java.util.TimerTask;	23	import java.util.TimerTask;
23	import java.util.concurrent.ConcurrentHashMap;	24	import java.util.concurrent.ConcurrentHashMap;
		25	import java.util.regex.Matcher;
		26	import java.util.regex.Pattern;
24		27
25	import org.eclipse.core.runtime.Platform;	28	import org.eclipse.core.runtime.Platform;
26	import org.eclipse.jface.dialogs.MessageDialog;	29	import org.eclipse.jface.dialogs.MessageDialog;
Lines 48-53 Link Here
48	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	51	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
49	import org.eclipse.mylyn.monitor.core.InteractionEvent;	52	import org.eclipse.mylyn.monitor.core.InteractionEvent;
50	import org.eclipse.mylyn.monitor.core.StatusHandler;	53	import org.eclipse.mylyn.monitor.core.StatusHandler;
		54	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
		55	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
51	import org.eclipse.mylyn.tasks.core.AbstractTask;	56	import org.eclipse.mylyn.tasks.core.AbstractTask;
52	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	57	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
53	import org.eclipse.mylyn.tasks.core.ITaskActivityListener;	58	import org.eclipse.mylyn.tasks.core.ITaskActivityListener;
Lines 67-72 Link Here
67	*	72	*
68	* @author Mik Kersten	73	* @author Mik Kersten
69	* @author Rob Elves (task activity)	74	* @author Rob Elves (task activity)
		75	* @author Jevgeni Holodkov (insertQueries)
70	* @since 2.0	76	* @since 2.0
71	*/	77	*/
72	public class TaskListManager implements IPropertyChangeListener {	78	public class TaskListManager implements IPropertyChangeListener {
Lines 1190-1193 Link Here
1190	return newTask;	1196	return newTask;
1191	}	1197	}
1192		1198
		1199
		1200	/**
		1201	* Imports Queries to the TaskList and synchronize them with the repository. If the imported query have the
		1202	* name that overlaps with the existing one, the the suffix [x] is added, where x is a number starting from 1.
		1203	* @param queries to insert
		1204	* @return the list queries, which were not inserted since because the related repository was not found.
		1205	*/
		1206	public List<AbstractRepositoryQuery> insertQueries(List<AbstractRepositoryQuery> queries) {
		1207	List<AbstractRepositoryQuery> badQueries = new ArrayList<AbstractRepositoryQuery>();
		1208
		1209	String patternStr = "\\[(\\d+)\\]$"; // all string that end with [x], where x is a number
		1210	Pattern pattern = Pattern.compile(patternStr);
		1211
		1212	for (AbstractRepositoryQuery query : queries) {
		1213
		1214	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
		1215	query.getRepositoryKind(), query.getRepositoryUrl());
		1216	if (repository == null) {
		1217	badQueries.add(query);
		1218	continue;
		1219	}
		1220
		1221	// resolve name conflict
		1222	{
		1223	Set<AbstractRepositoryQuery> existingQueries = getTaskList().getQueries();
		1224	Map<String, AbstractRepositoryQuery> queryMap = new HashMap<String, AbstractRepositoryQuery>();
		1225	for (AbstractRepositoryQuery existingQuery : existingQueries) {
		1226	queryMap.put(existingQuery.getHandleIdentifier(), existingQuery);
		1227	}
		1228
		1229	// suggest a new handle if needed
		1230	String handle = query.getHandleIdentifier();
		1231
		1232	while (queryMap.get(handle) != null) {
		1233	Matcher matcher = pattern.matcher(handle);
		1234	boolean matchFound = matcher.find();
		1235	if (matchFound) {
		1236	// increment index
		1237	int index = Integer.parseInt(matcher.group(1));
		1238	index++;
		1239	handle = matcher.replaceAll("[" + index + "]");
		1240	} else {
		1241	handle += "[1]";
		1242	}
		1243	}
		1244	query.setHandleIdentifier(handle);
		1245	}
		1246
		1247	// add query
		1248	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(query);
		1249
		1250	AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
		1251	.getRepositoryConnector(repository.getConnectorKind());
		1252	if (connector != null) {
		1253	TasksUiPlugin.getSynchronizationManager().synchronize(connector, query, null, true);
		1254	}
		1255
		1256	}
		1257
		1258	return badQueries;
		1259	}
		1260
1193	}	1261	}

Return to bug 189518

Lines 13-26 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java (-8 / +167 lines)
13		13
14	import java.io.File;	14	import java.io.File;
15	import java.util.ArrayList;	15	import java.util.ArrayList;
		16	import java.util.HashMap;
16	import java.util.List;	17	import java.util.List;
		18	import java.util.Map;
17	import java.util.Set;	19	import java.util.Set;
18		20
19	import junit.framework.TestCase;	21	import junit.framework.TestCase;
20		22
21	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	23	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
22	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;	24	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
23	import org.eclipse.mylyn.tasks.core.TaskList;	25	import org.eclipse.mylyn.tasks.core.TaskRepository;
		26	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
24	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;	27	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
25	import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;	28	import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;
26	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	29	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
Lines 46-51 Link Here
46	dest.mkdir();	49	dest.mkdir();
47	}	50	}
48	assertTrue(dest.exists());	51	assertTrue(dest.exists());
		52	TasksUiPlugin.getSynchronizationManager().setForceSyncExec(true);
49	}	53	}
50		54
51	@Override	55	@Override
Lines 55-60 Link Here
55	removeFiles(dest);	59	removeFiles(dest);
56	dest.delete();	60	dest.delete();
57	assertFalse(dest.exists());	61	assertFalse(dest.exists());
		62	TasksUiPlugin.getSynchronizationManager().setForceSyncExec(false);
58	}	63	}
59		64
60	public void testExportImportQuery() {	65	public void testExportImportQuery() {
Lines 62-84 Link Here
62	externalizers.add(new MockTaskListFactory());	67	externalizers.add(new MockTaskListFactory());
63	TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);	68	TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);
64		69
65	MockRepositoryQuery query = new MockRepositoryQuery("Test Query");	70	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		71
		72	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		73	MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query 2");
		74	queries.add(query1);
		75	queries.add(query2);
66		76
67	File outFile = new File(dest, "test-query.xml.zip");	77	File outFile = new File(dest, "test-query.xml.zip");
68		78
69	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQuery(query, outFile);	79	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQueries(queries, outFile);
70	assertTrue(outFile.exists());	80	assertTrue(outFile.exists());
71		81
72	TaskList taskList = TasksUiPlugin.getTaskListManager().resetTaskList();
73
74	File inFile = new File(dest, "test-query.xml.zip");	82	File inFile = new File(dest, "test-query.xml.zip");
75	TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(taskList, inFile);	83	List<AbstractRepositoryQuery> resultQueries = TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(
76	Set<AbstractRepositoryQuery> queries = taskList.getQueries();	84	inFile);
77	assertEquals("1 Query is imported", 1, queries.size());	85	assertEquals("2 Queries is imported", 2, resultQueries.size());
		86	}
		87
		88	public void testImportedQueriesNameConflictResolving1() {
		89	// prepare for test
		90	TasksUiPlugin.getTaskListManager().resetTaskList();
		91	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		92	TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		93
		94	// create test data
		95	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		96
		97	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		98	query1.setRepositoryUrl(repository.getUrl());
		99	MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query");
		100	query2.setRepositoryUrl(repository.getUrl());
		101	MockRepositoryQuery query3 = new MockRepositoryQuery("Test Query");
		102	query3.setRepositoryUrl(repository.getUrl());
		103
		104	queries.add(query1);
		105	queries.add(query2);
		106	queries.add(query3);
		107
		108	// run tested functionality
		109	TasksUiPlugin.getTaskListManager().insertQueries(queries);
		110
		111	// extract results
		112	Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		113	Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		114	for (AbstractRepositoryQuery query : queriesSet) {
		115	queriesMap.put(query.getHandleIdentifier(), query);
		116	}
		117
		118	// check that the actual result is correct
		119	assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
		120	assertTrue("'Test Query[1]' query inserted", queriesMap.containsKey("Test Query[1]"));
		121	assertTrue("'Test Query[2]' query inserted", queriesMap.containsKey("Test Query[2]"));
78	}	122	}
79		123
		124
		125	public void testImportedQueriesNameConflictResolving2() {
		126	// prepare for test
		127	TasksUiPlugin.getTaskListManager().resetTaskList();
		128	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		129	TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		130
		131	// create test data
		132	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		133
		134	MockRepositoryQuery query1 = new MockRepositoryQuery("Test2");
		135	query1.setRepositoryUrl(repository.getUrl());
		136	MockRepositoryQuery query2 = new MockRepositoryQuery("Test2[1]");
		137	query2.setRepositoryUrl(repository.getUrl());
		138	MockRepositoryQuery query3 = new MockRepositoryQuery("Test2");
		139	query3.setRepositoryUrl(repository.getUrl());
		140
		141	queries.add(query1);
		142	queries.add(query2);
		143	queries.add(query3);
		144
		145	// run tested functionality
		146	TasksUiPlugin.getTaskListManager().insertQueries(queries);
		147
		148	// extract results
		149	Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		150	Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		151	for (AbstractRepositoryQuery query : queriesSet) {
		152	queriesMap.put(query.getHandleIdentifier(), query);
		153	}
		154
		155	// check that the actual result is correct
		156	assertTrue("'Test2' query inserted", queriesMap.containsKey("Test2"));
		157	assertTrue("'Test2[1]' query inserted", queriesMap.containsKey("Test2[1]"));
		158	assertTrue("'Test2[2]' query inserted", queriesMap.containsKey("Test2[2]"));
		159
		160	}
80		161
81		162
		163	public void testImportedBadQueriesNameConflictResolving() {
		164	// prepare for test
		165	TasksUiPlugin.getTaskListManager().resetTaskList();
		166	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		167	TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		168
		169	// create test data
		170	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		171
		172	MockRepositoryQuery query1 = new MockRepositoryQuery("Test[-10]");
		173	query1.setRepositoryUrl(repository.getUrl());
		174	MockRepositoryQuery query2 = new MockRepositoryQuery("Test[ABC]");
		175	query2.setRepositoryUrl(repository.getUrl());
		176	MockRepositoryQuery query3 = new MockRepositoryQuery("Test[1]");
		177	query3.setRepositoryUrl(repository.getUrl());
		178	MockRepositoryQuery query4 = new MockRepositoryQuery("Test");
		179	query4.setRepositoryUrl(repository.getUrl());
		180	MockRepositoryQuery query5 = new MockRepositoryQuery("Test");
		181	query5.setRepositoryUrl(repository.getUrl());
		182
		183	queries.add(query1);
		184	queries.add(query2);
		185	queries.add(query3);
		186	queries.add(query4);
		187	queries.add(query5);
		188
		189	// run tested functionality
		190	TasksUiPlugin.getTaskListManager().insertQueries(queries);
		191
		192	// extract results
		193	Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		194	Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		195	for (AbstractRepositoryQuery query : queriesSet) {
		196	queriesMap.put(query.getHandleIdentifier(), query);
		197	}
		198
		199	// check that the actual result is correct
		200	assertTrue("'Test[-10]' query inserted", queriesMap.containsKey("Test[-10]"));
		201	assertTrue("'Test[ABC]' query inserted", queriesMap.containsKey("Test[ABC]"));
		202	assertTrue("'Test[1]' query inserted", queriesMap.containsKey("Test[1]"));
		203	assertTrue("'Test' query inserted", queriesMap.containsKey("Test"));
		204	assertTrue("Another 'Test' query inserted", queriesMap.containsKey("Test[2]"));
		205	}
		206
		207	public void testImportedBadQueries() {
		208	// prepare for test
		209	TasksUiPlugin.getTaskListManager().resetTaskList();
		210	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		211	TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		212
		213	// create test data
		214	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		215
		216	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		217	query1.setRepositoryUrl(repository.getUrl());
		218	MockRepositoryQuery query2 = new MockRepositoryQuery("Bad Query");
		219	query2.setRepositoryUrl("bad url");
		220
		221	queries.add(query1);
		222	queries.add(query2);
		223
		224	// run tested functionality
		225	List<AbstractRepositoryQuery> badQueries = TasksUiPlugin.getTaskListManager().insertQueries(queries);
		226
227	// extract results
228	Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
229	Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
230	for (AbstractRepositoryQuery query : queriesSet) {
231	queriesMap.put(query.getHandleIdentifier(), query);
232	}
233
234	// check that the actual result is correct
235	assertEquals("There is a bad query", 1, badQueries.size());
236	assertEquals(query2, badQueries.get(0));
237	assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
238	}
239
240
82	private void removeFiles(File root) {	241	private void removeFiles(File root) {
83	if (root.isDirectory()) {	242	if (root.isDirectory()) {
84	for (File file : root.listFiles()) {	243	for (File file : root.listFiles()) {

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryConnector.java (-2 / +2 lines)
14	import org.eclipse.core.runtime.CoreException;	14	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.core.runtime.IProgressMonitor;	15	import org.eclipse.core.runtime.IProgressMonitor;
16	import org.eclipse.core.runtime.IStatus;	16	import org.eclipse.core.runtime.IStatus;
		17	import org.eclipse.core.runtime.Status;
17	import org.eclipse.mylyn.tasks.core.AbstractAttachmentHandler;	18	import org.eclipse.mylyn.tasks.core.AbstractAttachmentHandler;
18	import org.eclipse.mylyn.tasks.core.AbstractAttributeFactory;	19	import org.eclipse.mylyn.tasks.core.AbstractAttributeFactory;
19	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;	20	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
Lines 160-167 Link Here
160	@Override	161	@Override
161	public IStatus performQuery(AbstractRepositoryQuery query, TaskRepository repository, IProgressMonitor monitor,	162	public IStatus performQuery(AbstractRepositoryQuery query, TaskRepository repository, IProgressMonitor monitor,
162	ITaskCollector resultCollector) {	163	ITaskCollector resultCollector) {
163	// ignore	164	return Status.OK_STATUS;
164	return null;
165	}	165	}
166		166
167	public void setAttachmentHandler(AbstractAttachmentHandler attachmentHandler) {	167	public void setAttachmentHandler(AbstractAttachmentHandler attachmentHandler) {