Attachment #74255 for bug #189518

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

Lines 57-62 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java (-42 / +85 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
		524
		525
		526
		527
		528
		529	for (AbstractRepositoryQuery query : queries) {
499	try {	530	try {
500	delagatingExternalizer.createQueryElement(query, doc, root);	531	delagatingExternalizer.createQueryElement(query, doc, root);
501	} catch (Throwable t) {	532	} catch (Throwable t) {
502	StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);	533	StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);
		534	return null;
503	}	535	}
		536	}
504		537
505	doc.appendChild(root);	538	doc.appendChild(root);
506	writeDOMtoFile(doc, outFile);	539	return doc;
507	return;
508	}	540	}
509		541
510	public void readQueries(TaskList taskList, File inFile) {	542	public List<AbstractRepositoryQuery> readQueries(File inFile) {
		543	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
511	try {	544	try {
512	if (!inFile.exists())	545	if (!inFile.exists())
513	return;	546	return queries;
514	Document doc = openAsDOM(inFile);	547	Document doc = openAsDOM(inFile);
515	if (doc == null) {	548	if (doc == null) {
516	handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));	549	handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));
517	return;	550	return queries;
518	}	551	}
519	Element root = doc.getDocumentElement();	552	queries = readQueryDocument(doc);
520	readVersion = root.getAttribute(ATTRIBUTE_VERSION);	553	} catch (Exception e) {
521		554	handleException(inFile, null, e);
522	if (!readVersion.equals(VALUE_VERSION_1_0_0)) {	555	}
523	NodeList list = root.getChildNodes();	556
		557	return queries;
		558	}
524		559
525	// read queries	560	/**
526	for (int i = 0; i < list.getLength(); i++) {	561	* @param Query document to read.
527	Node child = list.item(i);	562	*/
528	try {	563	public List<AbstractRepositoryQuery> readQueryDocument(Document doc) {
529	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {	564	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
530	readQuery(taskList, child);	565	Element root = doc.getDocumentElement();
		566	readVersion = root.getAttribute(ATTRIBUTE_VERSION);
		567
		568	if (!readVersion.equals(VALUE_VERSION_1_0_0)) {
		569	NodeList list = root.getChildNodes();
		570
		571	// read queries
		572	for (int i = 0; i < list.getLength(); i++) {
		573	Node child = list.item(i);
		574	try {
		575	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
		576	AbstractRepositoryQuery query = readQuery(null, child);
		577	if (query != null) {
		578	queries.add(query);
531	}	579	}
532	} catch (Exception e) {
533	handleException(inFile, child, e);
534	}	580	}
		581	} catch (Exception e) {
		582	StatusHandler.log(e, "Tasks may have been lost from " + child.getNodeName());
535	}	583	}
536	} else {
537	StatusHandler.log("version: " + readVersion + " not supported", this);
538	}	584	}
539	} catch (Exception e) {	585	} else {
540	handleException(inFile, null, e);	586	StatusHandler.log("version: " + readVersion + " not supported", this);
541	}	587	}
542		588
543	if (!hasCaughtException) {	589	return queries;
544	// save new task list only if there were no exception!
545	writeTaskList(taskList, inFile);
546	}
547	}	590	}
548	}	591	}

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	}





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;

		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()) {

Return to bug 189518

Lines 13-26 Link Here

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