/*******************************************************************************
 * Copyright (c) 2015 Tasktop Technologies.
 * 
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.migrator;

import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import java.io.File;
import java.io.IOException;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.internal.tasks.core.DateRange;
import org.eclipse.mylyn.internal.tasks.core.IRepositoryConstants;
import org.eclipse.mylyn.internal.tasks.core.RepositoryModel;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.core.TaskJobFactory;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.core.TaskTask;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.internal.tasks.ui.TaskListBackupManager;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.context.AbstractTaskContextStore;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tests.util.TestFixture;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;

import com.google.common.base.Optional;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;

public class ConnectorMigratorTest {
	public class SpyTasksState extends DefaultTasksState {

		TaskActivityManager taskActivityManager = spy(super.getTaskActivityManager());

		TaskDataManager taskDataManager = spy(super.getTaskDataManager());

		RepositoryModel repositoryModel = spy(super.getRepositoryModel());

		TaskList taskList = spy(super.getTaskList());

		AbstractTaskContextStore contextStore = spy(super.getContextStore());

		TaskJobFactory taskJobFactory = spy(super.getTaskJobFactory());

		TaskRepositoryManager repositoryManager = spy(super.getRepositoryManager());

		@Override
		public TaskActivityManager getTaskActivityManager() {
			return taskActivityManager;
		}

		@Override
		public TaskDataManager getTaskDataManager() {
			return taskDataManager;
		}

		@Override
		public RepositoryModel getRepositoryModel() {
			return repositoryModel;
		}

		@Override
		public TaskList getTaskList() {
			return taskList;
		}

		@Override
		public AbstractTaskContextStore getContextStore() {
			return contextStore;
		}

		@Override
		public TaskJobFactory getTaskJobFactory() {
			return taskJobFactory;
		}

		@Override
		public TaskRepositoryManager getRepositoryManager() {
			return repositoryManager;
		}

	}

	private final ImmutableMap<String, String> kinds = ImmutableMap.of("mock", "mock.new");

	private final TaskRepository repository = new TaskRepository("mock", "http://mock");

	private final ImmutableSet<TaskRepository> singleRepository = ImmutableSet.of(repository);

	private TaskRepository migratedRepository = new TaskRepository("mock.new", "http://mock");

	private final AuthenticationCredentials repoCreds = new AuthenticationCredentials("u1", "p1");

	private final AuthenticationCredentials proxyCreds = new AuthenticationCredentials("u2", "p2");

	private final AuthenticationCredentials httpCreds = new AuthenticationCredentials("u3", "p3");

	private final AuthenticationCredentials certCreds = new AuthenticationCredentials("u4", "p4");

	private final AbstractRepositoryConnector connector = mock(AbstractRepositoryConnector.class);

	private final AbstractRepositoryConnector newConnector = mock(AbstractRepositoryConnector.class);

	private final TaskListView taskList = mock(TaskListView.class);

	private final TaskListBackupManager backupManager = mock(TaskListBackupManager.class);

	DefaultTasksState tasksState = spy(new SpyTasksState());

	private TaskRepositoryManager manager = tasksState.getRepositoryManager();

	private final ConnectorMigrationUi migrationUi = spy(new ConnectorMigrationUi(taskList, backupManager, tasksState));

	@SuppressWarnings("unchecked")
	@Before
	public void setUp() {
		doNothing().when(migrationUi).warnOfValidationFailure(any(List.class));
		doNothing().when(migrationUi).notifyMigrationComplete();
	}

	@After
	public void tearDown() throws Exception {
		TestFixture.resetTaskList();
		new File("test-context.zip").delete();
	}

	@Test
	public void setConnectorsToMigrate() throws Exception {
		ConnectorMigrator migrator = createMigrator(true, true, ImmutableMap.of("mock", "mock.new", "kind", "kind.new"),
				ImmutableSet.of(repository, new TaskRepository("kind", "http://mock")), true);
		try {
			migrator.setConnectorsToMigrate(ImmutableList.of("foo"));
			fail("Expected IllegalArgumentException");
		} catch (IllegalArgumentException e) {// NOSONAR
		}
		migrator.setConnectorsToMigrate(ImmutableList.of("kind"));
		assertEquals(ImmutableMap.of("kind", "kind.new"), migrator.getSelectedConnectors());
	}

	@SuppressWarnings("unchecked")
	@Test
	public void migrateConnectors() throws Exception {
		assertMigrateConnectors();
		verify(migrationUi, never()).warnOfValidationFailure((List<TaskRepository>) any());
	}

	@Test
	public void migrateConnectorsValidationFailure() throws Exception {
		when(newConnector.validateRepository(any(TaskRepository.class), any(IProgressMonitor.class))).thenThrow(
				new CoreException(new Status(0, "org.eclipse.mylyn.tasks.ui.tests", 0, "Error", new Exception())));
		assertMigrateConnectors();
		verify(migrationUi).warnOfValidationFailure(ImmutableList.of(migratedRepository));
	}

	@Test
	public void cancelMigration() throws Exception {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, singleRepository, true));
		IProgressMonitor monitor = new NullProgressMonitor();
		monitor.setCanceled(true);
		IProgressMonitor spyMonitor = spy(monitor);
		try {
			migrator.setConnectorsToMigrate(ImmutableList.of("mock"));
			migrator.migrateConnectors(spyMonitor);
			fail("Expected OperationCanceledException");
		} catch (OperationCanceledException e) {// NOSONAR
		}
		verify(spyMonitor).beginTask("Migrating repositories", 2);
		verify(spyMonitor).isCanceled();
		verify(manager, never()).getRepositoryConnector(any(String.class));
		verify(manager, never()).addRepository(any(TaskRepository.class));
		verify(migrator, never()).getMigratedRepository(any(String.class), any(TaskRepository.class));
	}

	private ConnectorMigrator assertMigrateConnectors() throws CoreException, IOException {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, singleRepository, true));
		IProgressMonitor monitor = migrateConnectors(migrator);

		assertTrue(repository.isOffline());
		assertEquals("http://mock (Unsupported, do not delete)", repository.getRepositoryLabel());
		InOrder inOrder = inOrder(manager, newConnector, migrationUi, migrator, monitor);
		inOrder.verify(monitor).beginTask("Migrating repositories", 2);

		inOrder.verify(migrationUi).backupTaskList(monitor);
		inOrder.verify(monitor).subTask("Backing up task list");
		inOrder.verify(monitor).worked(1);

		inOrder.verify(monitor).subTask("Migrating http://mock");
		inOrder.verify(migrator).migrateRepository("mock.new", "http://mock", repository);
		inOrder.verify(manager).addRepository(migratedRepository);
		inOrder.verify(migrator).disconnect(repository);
		inOrder.verify(monitor).worked(1);
		inOrder.verify(monitor).beginTask("Validating repository connections", 1);
		inOrder.verify(monitor).subTask("Validating connection to http://mock");
		inOrder.verify(newConnector).validateRepository(migratedRepository, monitor);
		inOrder.verify(monitor).done();
		verifyNoMoreInteractions(newConnector);
		return migrator;
	}

	private IProgressMonitor migrateConnectors(ConnectorMigrator migrator) throws IOException {
		IProgressMonitor monitor = mock(IProgressMonitor.class);
		migrator.setConnectorsToMigrate(ImmutableList.of("mock"));
		migrator.migrateConnectors(monitor);
		return monitor;
	}

	@Test
	public void migrateRepository() throws Exception {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, singleRepository, true);
		populateRepository();

		migratedRepository = migrator.getMigratedRepository("mock.new", repository);
		assertEquals("foovalue", migratedRepository.getProperty("foo"));
		assertEquals("barvalue", migratedRepository.getProperty("bar"));
		assertNull(migratedRepository.getProperty(IRepositoryConstants.PROPERTY_SYNCTIMESTAMP));
		assertEquals("My Label", migratedRepository.getRepositoryLabel());
		assertEquals("mock.new", migratedRepository.getConnectorKind());

		assertEquals(repoCreds, migratedRepository.getCredentials(AuthenticationType.REPOSITORY));
		assertEquals(proxyCreds, migratedRepository.getCredentials(AuthenticationType.PROXY));
		assertEquals(httpCreds, migratedRepository.getCredentials(AuthenticationType.HTTP));
		assertEquals(certCreds, migratedRepository.getCredentials(AuthenticationType.CERTIFICATE));

		assertTrue(migratedRepository.getSavePassword(AuthenticationType.REPOSITORY));
		assertTrue(migratedRepository.getSavePassword(AuthenticationType.PROXY));
		assertFalse(migratedRepository.getSavePassword(AuthenticationType.HTTP));
		assertFalse(migratedRepository.getSavePassword(AuthenticationType.CERTIFICATE));
	}

	@Test
	public void migrateExistingRepositoryDoesNothing() throws Exception {
		migratedRepository.setRepositoryLabel("My Old Label");

		ConnectorMigrator migrator = createMigrator(true, true, kinds, singleRepository, true);
		when(manager.getRepository("mock.new", "http://mock")).thenReturn(migratedRepository);
		populateRepository();

		assertSame(migratedRepository, migrator.getMigratedRepository("mock.new", repository));
		assertNull(migratedRepository.getProperty("foo"));
		assertNull(migratedRepository.getProperty("bar"));
		assertNull(migratedRepository.getProperty(IRepositoryConstants.PROPERTY_SYNCTIMESTAMP));
		assertEquals("My Old Label", migratedRepository.getRepositoryLabel());
		assertEquals("mock.new", migratedRepository.getConnectorKind());

		assertNull(migratedRepository.getCredentials(AuthenticationType.REPOSITORY));
		assertNull(migratedRepository.getCredentials(AuthenticationType.PROXY));
		assertNull(migratedRepository.getCredentials(AuthenticationType.HTTP));
		assertNull(migratedRepository.getCredentials(AuthenticationType.CERTIFICATE));

	}

	private void populateRepository() {
		repository.setProperty("foo", "foovalue");
		repository.setProperty("bar", "barvalue");
		repository.setProperty(IRepositoryConstants.PROPERTY_SYNCTIMESTAMP, "123");
		repository.setRepositoryLabel("My Label");
		repository.setCredentials(AuthenticationType.REPOSITORY, repoCreds, true);
		repository.setCredentials(AuthenticationType.PROXY, proxyCreds, true);
		repository.setCredentials(AuthenticationType.HTTP, httpCreds, false);
		repository.setCredentials(AuthenticationType.CERTIFICATE, certCreds, false);
	}

	@Test
	public void needsMigrationEmptyKinds() {
		try {
			createMigrator(true, true, ImmutableMap.<String, String> of(), singleRepository, true);
			fail("Expected IllegalArgumentException");
		} catch (IllegalArgumentException e) {// NOSONAR
		}
	}

	@Test
	public void needsMigrationNoRepositories() {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, ImmutableSet.<TaskRepository> of(), true);
		assertFalse(migrator.needsMigration());
	}

	@Test
	public void needsMigrationNoConnectors() {
		ConnectorMigrator migrator = createMigrator(false, false, kinds, singleRepository, true);
		assertFalse(migrator.needsMigration());
	}

	@Test
	public void needsMigrationNoNewConnector() {
		ConnectorMigrator migrator = createMigrator(true, false, kinds, singleRepository, true);
		assertFalse(migrator.needsMigration());
	}

	@Test
	public void needsMigrationNoOldConnector() {
		ConnectorMigrator migrator = createMigrator(false, true, kinds, singleRepository, true);
		assertFalse(migrator.needsMigration());
	}

	@Test
	public void needsMigrationOneRepository() {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, singleRepository, true);
		assertTrue(migrator.needsMigration());
	}

	@Test
	public void needsMigrationMultipleRepositories() {
		ConnectorMigrator migrator = createMigrator(true, true, kinds,
				ImmutableSet.of(repository, new TaskRepository("mock", "http://mock2")), true);
		assertTrue(migrator.needsMigration());
	}

	@Test
	public void needsMigrationMultiKindsOneRepository() {
		ImmutableMap<String, String> multiKinds = ImmutableMap.of("mock", "mock.new", "kind", "kind.new");
		ConnectorMigrator migrator = createMigrator(true, true, multiKinds, singleRepository, true);
		assertTrue(migrator.needsMigration());

		migrator = createMigrator(true, true, multiKinds, ImmutableSet.of(new TaskRepository("kind", "http://mock")),
				true);
		assertTrue(migrator.needsMigration());
	}

	@Test
	public void needsMigrationMultiKindsMultiRepositories() {
		ConnectorMigrator migrator = createMigrator(true, true, ImmutableMap.of("mock", "mock.new", "kind", "kind.new"),
				ImmutableSet.of(repository, new TaskRepository("kind", "http://mock")), true);
		assertTrue(migrator.needsMigration());
	}

	@Test
	public void migrateTasksWaitsForSyncJobs() throws Exception {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		JobListener listener = mock(JobListener.class);
		when(listener.isComplete()).thenReturn(false, false, true);
		when(migrator.getSyncTaskJobListener()).thenReturn(listener);
		migrator.migrateTasks(new NullProgressMonitor());
		verify(listener, times(3)).isComplete();
	}

	@Test
	public void migrateTasks() throws Exception {
		when(newConnector.getConnectorKind()).thenReturn("mock.new");
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		TaskData taskData2 = new TaskData(mock(TaskAttributeMapper.class), "mock.new", repository.getRepositoryUrl(),
				"2.migrated");
		doReturn(taskData2).when(migrator).getTaskData(eq("key2"), eq(newConnector), any(TaskRepository.class),
				any(IProgressMonitor.class));
		ITask task1 = new TaskTask("mock", "http://mock", "1");
		task1.setTaskKey("key1");
		((AbstractTask) task1).setSynchronizationState(SynchronizationState.INCOMING_NEW);
		ITask task2 = new TaskTask("mock", "http://mock", "2");
		task2.setTaskKey("key2");
		((AbstractTask) task2).setSynchronizationState(SynchronizationState.INCOMING);
		ITask task1Migrated = new TaskTask("mock.new", "http://mock", "1.migrated");
		task1Migrated.setTaskKey("key1");
		TaskTask taskOtherRepo = new TaskTask("mock", "http://other-mock", "1");
		tasksState.getTaskList().addTask(task1);
		tasksState.getTaskList().addTask(task1Migrated);
		tasksState.getTaskList().addTask(taskOtherRepo);
		tasksState.getTaskList().addTask(task2);
		RepositoryQuery query = new RepositoryQuery("mock", "mock");
		query.setRepositoryUrl("http://mock");
		tasksState.getTaskList().addQuery(query);
		migrateConnectors(migrator);
		NullProgressMonitor monitor = new NullProgressMonitor();

		migrator.migrateTasks(monitor);
		verify(tasksState.getTaskActivityManager()).deactivateActiveTask();
		TaskRepository newRepository = manager.getRepository("mock.new", "http://mock");
		verify(migrator).migrateTasks(ImmutableSet.of(task1, task2), repository, newRepository,
				manager.getRepositoryConnector("mock.new"), monitor);

		verify(migrator, never()).getTaskData("key1", newConnector, newRepository, monitor);
		verify(migrator, never()).createTask(argThat(not(taskData2)), any(TaskRepository.class));
		verify(migrator).getTaskData("key2", newConnector, newRepository, monitor);
		verify(migrator).createTask(taskData2, newRepository);
		verify(migrator).migratePrivateData((AbstractTask) task1, (AbstractTask) task1Migrated, monitor);
		ITask task2Migrated = new TaskTask("mock.new", "http://mock", "2.migrated");
		task2Migrated.setTaskKey("key2");
		verify(migrator).migratePrivateData((AbstractTask) task2, (AbstractTask) task2Migrated, monitor);

		verify(migrationUi).delete(ImmutableSet.of(task1, task2), repository, newRepository, monitor);
		assertEquals(SynchronizationState.INCOMING_NEW, tasksState.getTaskList()
				.getTask(repository.getRepositoryUrl(), "1.migrated")
				.getSynchronizationState());
		assertEquals(SynchronizationState.INCOMING, tasksState.getTaskList()
				.getTask(repository.getRepositoryUrl(), "2.migrated")
				.getSynchronizationState());

		assertEquals(ImmutableSet.of(taskOtherRepo, task1Migrated, task2Migrated),
				ImmutableSet.copyOf(tasksState.getTaskList().getAllTasks()));
		verify(tasksState.getRepositoryManager()).removeRepository(repository);
		assertTrue(tasksState.getTaskList().getQueries().isEmpty());
		assertEquals(ImmutableSet.of(newRepository), tasksState.getRepositoryManager().getRepositories("mock.new"));
	}

	@Test
	public void migrateTasksSameId() throws Exception {
		when(newConnector.getConnectorKind()).thenReturn("mock.new");
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		TaskData taskData1 = new TaskData(mock(TaskAttributeMapper.class), "mock.new", repository.getRepositoryUrl(),
				"1");
		doReturn(taskData1).when(migrator).getTaskData(eq("key1"), eq(newConnector), any(TaskRepository.class),
				any(IProgressMonitor.class));
		TaskData taskData2 = new TaskData(mock(TaskAttributeMapper.class), "mock.new", repository.getRepositoryUrl(),
				"2");
		doReturn(taskData2).when(migrator).getTaskData(eq("key2"), eq(newConnector), any(TaskRepository.class),
				any(IProgressMonitor.class));
		ITask task1 = new TaskTask("mock", "http://mock", "1");
		task1.setTaskKey("key1");
		((AbstractTask) task1).setSynchronizationState(SynchronizationState.INCOMING_NEW);
		ITask task2 = new TaskTask("mock", "http://mock", "2");
		task2.setTaskKey("key2");
		((AbstractTask) task2).setSynchronizationState(SynchronizationState.INCOMING);
		ITask task1Migrated = new TaskTask("mock.new", "http://mock", "1");
		task1Migrated.setTaskKey("key1");
		TaskTask taskOtherRepo = new TaskTask("mock", "http://other-mock", "1");
		tasksState.getTaskList().addTask(task1);
		tasksState.getTaskList().addTask(task1Migrated);
		tasksState.getTaskList().addTask(taskOtherRepo);
		tasksState.getTaskList().addTask(task2);
		RepositoryQuery query = new RepositoryQuery("mock", "mock");
		query.setRepositoryUrl("http://mock");
		tasksState.getTaskList().addQuery(query);
		migrateConnectors(migrator);
		NullProgressMonitor monitor = new NullProgressMonitor();

		migrator.migrateTasks(monitor);
		verify(tasksState.getTaskActivityManager()).deactivateActiveTask();
		TaskRepository newRepository = manager.getRepository("mock.new", "http://mock");
		verify(migrator).migrateTasks(ImmutableSet.of(task1, task2), repository, newRepository,
				manager.getRepositoryConnector("mock.new"), monitor);

		verify(migrator).getTaskData("key1", newConnector, newRepository, monitor);
		verify(migrator).getTaskData("key2", newConnector, newRepository, monitor);
		verify(migrator).createTask(taskData2, newRepository);
		ITask task2Migrated = new TaskTask("mock.new", "http://mock", "2");
		task2Migrated.setTaskKey("key2");
		verify(migrator).migratePrivateData((AbstractTask) task2, (AbstractTask) task2Migrated, monitor);
		verify(migrator).migratePrivateData((AbstractTask) task1, (AbstractTask) task1Migrated, monitor);

		verify(migrationUi).delete(ImmutableSet.of(task1, task2), repository, newRepository, monitor);
		assertEquals(SynchronizationState.INCOMING_NEW,
				tasksState.getTaskList().getTask(repository.getRepositoryUrl(), "1").getSynchronizationState());
		assertEquals(SynchronizationState.INCOMING,
				tasksState.getTaskList().getTask(repository.getRepositoryUrl(), "2").getSynchronizationState());

		assertEquals(ImmutableSet.of(taskOtherRepo, task1Migrated, task2Migrated),
				ImmutableSet.copyOf(tasksState.getTaskList().getAllTasks()));
		verify(tasksState.getRepositoryManager()).removeRepository(repository);
		assertTrue(tasksState.getTaskList().getQueries().isEmpty());
		assertEquals(ImmutableSet.of(newRepository), tasksState.getRepositoryManager().getRepositories("mock.new"));
	}

	@Test
	public void migratePrivateData() throws Exception {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, ImmutableSet.of(repository), false);
		AbstractTask oldTask = new TaskTask("mock", "http://mock", "1");
		AbstractTask newTask = new TaskTask("mock.new", "http://mock", "1.migrated");

		oldTask.setNotes("some notes");
		DateRange scheduledDate = new DateRange(createCalendar(3));
		Calendar dueDate = createCalendar(5);
		tasksState.getTaskActivityManager().setScheduledFor(oldTask, scheduledDate);
		tasksState.getTaskActivityManager().setDueDate(oldTask, dueDate.getTime());
		oldTask.setEstimatedTimeHours(7);

		migrator.migratePrivateData(oldTask, newTask, new NullProgressMonitor());
		assertEquals("some notes", newTask.getNotes());
		assertEquals(scheduledDate, newTask.getScheduledForDate());
		assertEquals(dueDate.getTime(), newTask.getDueDate());
		assertEquals(7, newTask.getEstimatedTimeHours());
	}

	@Test
	public void migrateCategories() throws Exception {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, ImmutableSet.of(repository), false);
		AbstractTask oldTask1 = new TaskTask("mock", "http://mock", "1");
		AbstractTask oldTask2 = new TaskTask("mock", "http://mock", "2");
		AbstractTask newTask1 = new TaskTask("mock.new", "http://mock", "1.migrated");
		AbstractTask newTask2 = new TaskTask("mock.new", "http://mock", "2.migrated");

		TaskCategory category1 = new TaskCategory("category1");
		TaskCategory category2 = new TaskCategory("category2");
		tasksState.getTaskList().addCategory(category1);
		tasksState.getTaskList().addCategory(category2);
		tasksState.getTaskList().addTask(oldTask1, category1);
		tasksState.getTaskList().addTask(oldTask2, category2);

		migrator.migratePrivateData(oldTask1, newTask1, new NullProgressMonitor());
		migrator.migratePrivateData(oldTask2, newTask2, new NullProgressMonitor());
		assertEquals(category1, getCategory(newTask1));
		assertEquals(category2, getCategory(newTask2));
	}

	@Test
	public void getCategories() throws Exception {
		ConnectorMigrator migrator = createMigrator(true, true, kinds, ImmutableSet.of(repository), false);
		AbstractTask oldTask1 = new TaskTask("mock", "http://mock", "1");
		AbstractTask oldTask2 = new TaskTask("mock", "http://mock", "2");
		AbstractTask newTask1 = new TaskTask("mock.new", "http://mock", "1.migrated");
		AbstractTask newTask2 = new TaskTask("mock.new", "http://mock", "2.migrated");

		TaskCategory category1 = new TaskCategory("category1");
		TaskCategory category2 = new TaskCategory("category2");
		tasksState.getTaskList().addCategory(category1);
		tasksState.getTaskList().addCategory(category2);
		tasksState.getTaskList().addTask(oldTask1, category1);
		tasksState.getTaskList().addTask(newTask1, category1);
		tasksState.getTaskList().addTask(oldTask2, category2);
		tasksState.getTaskList().addTask(newTask2, category2);
		tasksState.getTaskList().addTask(new TaskTask("mock.new", "http://mock", "not categorized"));

		ImmutableMap<AbstractTask, TaskCategory> expected = ImmutableMap.of(oldTask1, category1, oldTask2, category2,
				newTask1, category1, newTask2, category2);
		assertEquals(expected, migrator.getCategories());

		tasksState.getTaskList().addTask(new TaskTask("mock.new", "http://mock", "3"), category1);
		assertEquals(expected, migrator.getCategories());
	}

	@Test
	public void migrateNoQueries() {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		RepositoryQuery q1 = createQuery("q1", repository, migrator, false);
		RepositoryQuery q2 = createQuery("q2", repository, migrator, false);

		migrator.migrateQueries(repository, migratedRepository, new NullProgressMonitor());
		assertFalse(migrator.anyQueriesMigrated());
		assertFalse(migrator.allQueriesMigrated());
	}

	@Test
	public void migrateSomeQueries() {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		RepositoryQuery q1 = createQuery("q1", repository, migrator, true);
		RepositoryQuery q2 = createQuery("q2", repository, migrator, false);

		assertFalse(migrator.anyQueriesMigrated());
		assertTrue(migrator.allQueriesMigrated());

		migrator.migrateQueries(repository, migratedRepository, new NullProgressMonitor());
		assertTrue(migrator.anyQueriesMigrated());
		assertFalse(migrator.allQueriesMigrated());
	}

	@Test
	public void migrateAllQueries() {
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		RepositoryQuery q1 = createQuery("q1", repository, migrator, true);
		RepositoryQuery q2 = createQuery("q2", repository, migrator, true);

		migrator.migrateQueries(repository, migratedRepository, new NullProgressMonitor());
		assertTrue(migrator.anyQueriesMigrated());
		assertTrue(migrator.allQueriesMigrated());
	}

	@Test
	public void migrateSomeQueriesMultipleRepositories() {
		TaskRepository otherRepository = new TaskRepository("mock", "http://other-mock");
		ConnectorMigrator migrator = spy(
				createMigrator(true, true, kinds, ImmutableSet.of(repository, otherRepository), false));
		RepositoryQuery q1 = createQuery("q1", repository, migrator, true);
		RepositoryQuery q2 = createQuery("q2", repository, migrator, true);
		RepositoryQuery q3 = createQuery("q3", otherRepository, migrator, false);
		RepositoryQuery q4 = createQuery("q4", otherRepository, migrator, false);

		migrator.migrateQueries(repository, migratedRepository, new NullProgressMonitor());
		migrator.migrateQueries(otherRepository, migratedRepository, new NullProgressMonitor());
		assertTrue(migrator.anyQueriesMigrated());
		assertFalse(migrator.allQueriesMigrated());
	}

	@Test
	public void migrateAllQueriesMultipleRepositories() {
		TaskRepository otherRepository = new TaskRepository("mock", "http://other-mock");
		ConnectorMigrator migrator = spy(createMigrator(true, true, kinds, ImmutableSet.of(repository), false));
		RepositoryQuery q1 = createQuery("q1", repository, migrator, true);
		RepositoryQuery q2 = createQuery("q2", repository, migrator, true);
		RepositoryQuery q3 = createQuery("q3", otherRepository, migrator, true);
		RepositoryQuery q4 = createQuery("q4", otherRepository, migrator, true);

		migrator.migrateQueries(repository, migratedRepository, new NullProgressMonitor());
		migrator.migrateQueries(otherRepository, migratedRepository, new NullProgressMonitor());
		assertTrue(migrator.anyQueriesMigrated());
		assertTrue(migrator.allQueriesMigrated());
	}

	private RepositoryQuery createQuery(String handle, TaskRepository repository, ConnectorMigrator migrator,
			boolean shouldMigrate) {
		RepositoryQuery query = new RepositoryQuery(repository.getConnectorKind(), handle);
		query.setRepositoryUrl(repository.getRepositoryUrl());
		tasksState.getTaskList().addQuery(query);
		if (shouldMigrate) {
			RepositoryQuery migratedQuery = new RepositoryQuery(repository.getConnectorKind(), handle + ".migrated");
			migratedQuery.setRepositoryUrl(repository.getRepositoryUrl() + "/migrated");
			when(migrator.migrateQuery(eq(query), any(TaskRepository.class), any(TaskRepository.class),
					any(IProgressMonitor.class))).thenReturn(migratedQuery);
		}
		return query;
	}

	private AbstractTaskCategory getCategory(AbstractTask newTask) {
		for (AbstractTaskCategory category : tasksState.getTaskList().getCategories()) {
			Optional<ITask> task = Iterables.tryFind(category.getChildren(), Predicates.<ITask> equalTo(newTask));
			if (task.isPresent()) {
				return category;
			}
		}
		return null;
	}

	private Calendar createCalendar(int daysInFuture) {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_MONTH, daysInFuture);
		return cal;
	}

	private ConnectorMigrator createMigrator(boolean hasOldConnector, boolean hasNewConnector,
			Map<String, String> kinds, Set<TaskRepository> repositories, boolean mockManager) {
		if (mockManager) {
			manager = mock(TaskRepositoryManager.class);
		}
		when(tasksState.getRepositoryManager()).thenReturn(manager);
		ConnectorMigrator migrator = new ConnectorMigrator(kinds, "", tasksState, migrationUi);
		when(manager.getRepositories("mock")).thenReturn(repositories);
		if (hasOldConnector) {
			when(manager.getRepositoryConnector("mock")).thenReturn(connector);
			when(manager.getRepositoryConnector("kind")).thenReturn(connector);
		}
		if (hasNewConnector) {
			when(manager.getRepositoryConnector("mock.new")).thenReturn(newConnector);
			when(manager.getRepositoryConnector("kind.new")).thenReturn(newConnector);
		}
		return migrator;
	}

}