org.eclipse.mylyn.gerrit.tests/src/org/eclipse/mylyn/gerrit/tests/core/GerritSynchronizationTest.java

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

package org.eclipse.mylyn.gerrit.tests.core;

import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;

import java.io.File;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.mylyn.commons.sdk.util.UiTestUtil;
import org.eclipse.mylyn.gerrit.tests.support.GerritFixture;
import org.eclipse.mylyn.gerrit.tests.support.GerritHarness;
import org.eclipse.mylyn.internal.gerrit.core.GerritConnector;
import org.eclipse.mylyn.internal.gerrit.core.GerritCorePlugin;
import org.eclipse.mylyn.internal.gerrit.core.GerritQuery;
import org.eclipse.mylyn.internal.gerrit.core.GerritTaskSchema;
import org.eclipse.mylyn.internal.gerrit.core.client.GerritClient;
import org.eclipse.mylyn.internal.gerrit.core.client.GerritException;
import org.eclipse.mylyn.internal.gerrit.ui.GerritUiPlugin;
import org.eclipse.mylyn.internal.reviews.ui.RemoteUiFactoryProviderConfigurer;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.reviews.spi.edit.remote.AbstractRemoteEditFactoryProvider;
import org.eclipse.mylyn.reviews.spi.edit.remote.review.ReviewsRemoteEditFactoryProvider;
import org.eclipse.mylyn.reviews.ui.spi.remote.RemoteUiService;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
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.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskCommentMapper;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tests.util.TestFixture;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.google.gerrit.reviewdb.ApprovalCategoryValue;
import com.google.gerrit.reviewdb.Project;

import junit.framework.TestCase;

/**
 * @author Steffen Pingel
 */
public class GerritSynchronizationTest extends TestCase {

	private GerritHarness harness;

	private TaskRepository repository;

	private TaskDataManager taskDataManager;

	private TaskList taskList;

	private GerritClient client;

	@Override
	@Before
	public void setUp() throws Exception {
//		RemoteFactoryProviderConfigurer configurer = new TestFactoryProviderConfigurer();
//
//		GerritCorePlugin.getDefault().getConnector().setFactoryProviderConfigurer(configurer);
		GerritUiPlugin.getDefault();
		TasksUiPlugin.getDefault()
				.getPreferenceStore()
				.setValue(ITasksUiPreferenceConstants.REPOSITORY_SYNCH_SCHEDULE_ENABLED, false);
		// cancel any parallel query synchronization jobs
		Job.getJobManager().cancel(ITasksCoreConstants.JOB_FAMILY_SYNCHRONIZATION);

		TestFixture.resetTaskListAndRepositories();

		harness = GerritFixture.current().harness();
		repository = GerritFixture.current().singleRepository();
		GerritCorePlugin.getDefault()
				.getConnector()
				.setFactoryProviderConfigurer(new RemoteUiFactoryProviderConfigurer());
		client = GerritCorePlugin.getDefault().getConnector().getClient(repository);
		AbstractRemoteEditFactoryProvider abstractRemoteEditFactoryProvider = (AbstractRemoteEditFactoryProvider) client
				.getFactoryProvider();
		GerritCorePlugin.getDefault()
				.getConnector()
				.getFactoryProviderConfigurer()
				.configure(abstractRemoteEditFactoryProvider);

		assertThat(abstractRemoteEditFactoryProvider.getService(), instanceOf(RemoteUiService.class));
		taskList = TasksUiPlugin.getTaskList();
		taskDataManager = TasksUiPlugin.getTaskDataManager();

		harness.ensureOneReviewExists();
	}

	@After
	@Override
	public void tearDown() throws Exception {
		harness.dispose();
		TestFixture.resetTaskListAndRepositories();
		TasksUiPlugin.getRepositoryModel().clear();
	}

	@Test
	public void testSynchronizeBackgroundQueryTaskUpdated() throws Exception {
		ITask task = createAndSynchronizeQuery(false);
		String message = addComment(task);
		RepositoryQuery query = taskList.getQueries().iterator().next();
		synchronizeQuery(query, false);
		assertHasNewComment(task, message);
	}

	@Test
	public void testSynchronizeBackgroundTaskUpdated() throws Exception {
		ITask task = createAndSynchronizeQuery(false);
		String message = addComment(task);
		synchronizeTask(task, false);
		assertHasNewComment(task, message);
	}

	@Test
	public void testSynchronizeQueryNewTask() throws Exception {
		createAndSynchronizeQuery(true);
	}

	@Test
	public void testSynchronizeQueryTaskUpdated() throws Exception {
		ITask task = createAndSynchronizeQuery(true);
		String message = addComment(task);
		RepositoryQuery query = taskList.getQueries().iterator().next();
		synchronizeQuery(query, true);
		assertHasNewComment(task, message);
	}

	@Test
	public void testSynchronizeTaskUpdated() throws Exception {
		ITask task = createAndSynchronizeQuery(true);
		String message = addComment(task);
		synchronizeTask(task, true);
		assertHasNewComment(task, message);
	}

	@Test
	public void testGetFromChangeId() throws Exception {
		ITask task = createAndSynchronizeQuery(true);
		AbstractRepositoryConnector connector = TasksUi.getRepositoryConnector(repository.getConnectorKind());
		GerritClient client = ((GerritConnector) connector).getClient(repository);
		Project.NameKey project = new Project.NameKey(
				taskDataManager.getTaskData(task).getRoot().getMappedAttribute(TaskAttribute.PRODUCT).getValue());
		client.clearCachedBranches(project);
		assertNull(client.getCachedBranches(project));

		TaskData taskData = connector.getTaskData(repository, task.getTaskId(), new NullProgressMonitor());
		assertEquals(task.getTaskId(), taskData.getTaskId());
		assertNotNull(client.getCachedBranches(project));

		TaskAttribute changeIdAttribute = taskData.getRoot()
				.getAttribute(GerritTaskSchema.getDefault().CHANGE_ID.getKey());
		assertNotNull(changeIdAttribute);
		assertThat(task.getTaskId(), not(equalTo(changeIdAttribute.getValue())));
		TaskData taskDataFromChangeId = connector.getTaskData(repository, changeIdAttribute.getValue(),
				new NullProgressMonitor());
		assertEquals(task.getTaskId(), taskDataFromChangeId.getTaskId());
		assertEquals(taskData.getRoot().toString(), taskDataFromChangeId.getRoot().toString());
	}

	private String addComment(ITask task) throws GerritException {
		taskDataManager.setTaskRead(task, true);
		GerritClient client = GerritClient.create(null, harness.location());
		String message = "new comment, time: " + System.currentTimeMillis(); //$NON-NLS-1$
		client.publishComments(task.getTaskId(), 1, message, Collections.<ApprovalCategoryValue.Id> emptySet(), null);
		return message;
	}

	private void assertHasNewComment(ITask task, String message) throws CoreException {
		assertEquals(SynchronizationState.INCOMING, task.getSynchronizationState());

		// validate that task data was fully synchronized
		TaskData taskData = taskDataManager.getTaskData(task);
		List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData,
				TaskAttribute.TYPE_COMMENT);
		TaskCommentMapper lastComment = TaskCommentMapper.createFrom(comments.get(comments.size() - 1));
		assertEquals("Failure on " + GerritFixture.current().getRepositoryUrl() + "/" + task.getTaskId(), //$NON-NLS-1$
				"Patch Set 1:\n\n" + message, lastComment.getText());
	}

	private ITask assertTaskListHasOneTask() throws CoreException {
		assertTrue(taskList.getAllTasks().size() >= 1);
		ITask task = taskList.getAllTasks().iterator().next();
		assertEquals(repository.getUrl(), task.getRepositoryUrl());
		assertTrue(taskDataManager.hasTaskData(task));
		return task;
	}

	private ITask createAndSynchronizeQuery(boolean user) throws Exception {
		IRepositoryQuery query = TasksUi.getRepositoryModel().createRepositoryQuery(repository);
		query.setAttribute(GerritQuery.TYPE, GerritQuery.CUSTOM);
		query.setAttribute(GerritQuery.QUERY_STRING, harness.defaultQuery());
		taskList.addQuery((RepositoryQuery) query);

		synchronizeQuery((RepositoryQuery) query, user);

		ITask task = assertTaskListHasOneTask();
		assertEquals(SynchronizationState.INCOMING_NEW, task.getSynchronizationState());

		String filePath = client.getFactoryProvider().getDataLocator().getModelPath() + File.separator
				+ "org.eclipse.mylyn.gerrit-" + ReviewsRemoteEditFactoryProvider.asFileName(repository.getUrl())
				+ File.separator + "Review" + File.separator + task.getTaskId() + ".reviews";
		File file = new File(filePath);
		assertThat("File should exist at: " + filePath, file.exists(), is(true));

		return task;
	}

	private void synchronizeQuery(RepositoryQuery query, boolean user) throws InterruptedException {
		AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
				.getRepositoryConnector(repository.getConnectorKind());
		SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeQueriesJob(connector, repository,
				Collections.singleton(query));
		job.setUser(user);
		job.schedule();
		job.join();
		// wait for any query synchronization jobs scheduled by job above
		boolean synchronizing = true;
		while (synchronizing) {
			try {
				Job.getJobManager().join(ITasksCoreConstants.JOB_FAMILY_SYNCHRONIZATION, null);
				synchronizing = false;
			} catch (InterruptedException e) {
				// ignore interrupts caused by sync exec and spin the UI loop to process them
				UiTestUtil.waitForDisplay();
			}
		}
	}

	private void synchronizeTask(ITask task, boolean user) throws InterruptedException {
		SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeTasksJob(
				TasksUi.getRepositoryConnector(repository.getConnectorKind()), repository, Collections.singleton(task));
		job.setUser(user);
		job.schedule();
		boolean synchronizing = true;
		while (synchronizing) {
			try {
				job.join();
				synchronizing = false;
			} catch (InterruptedException e) {
				// ignore interrupts caused by sync exec and spin the UI loop to process them
				UiTestUtil.waitForDisplay();
			}
		}
	}

}