plugins/org.eclipse.emf.compare.ide.ui.tests.git/src/org/eclipse/emf/compare/ide/ui/tests/merge/GitResourceVariantTreeSubscriberTest.java

/*******************************************************************************
 * Copyright (C) 2015 Obeo 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
 *******************************************************************************/
package org.eclipse.emf.compare.ide.ui.tests.merge;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.io.File;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.compare.egit.internal.merge.GitResourceVariantTreeProvider;
import org.eclipse.emf.compare.egit.internal.merge.GitResourceVariantTreeSubscriber;
import org.eclipse.emf.compare.egit.internal.merge.TreeWalkResourceVariantTreeProvider;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.team.core.diff.IDiff;
import org.eclipse.team.core.diff.IThreeWayDiff;
import org.eclipse.team.core.history.IFileRevision;
import org.eclipse.team.core.mapping.provider.ResourceDiff;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.core.variants.IResourceVariant;
import org.junit.Before;
import org.junit.Test;

public class GitResourceVariantTreeSubscriberTest extends VariantsTestCase {
	private static final String BRANCH_CHANGES = "branch changes\n";

	private static final String MASTER_CHANGES = "\nsome changes";

	private static final String BASE = "base";

	private File file1;

	private File file2;

	private IFile iFile1;

	private IFile iFile2;

	@Override
	@Before
	public void setUp() throws Exception {
		super.setUp();

		file1 = repository.createFile(iProject, "file1");
		file2 = repository.createFile(iProject, "file2");

		iFile1 = repository.getIFile(iProject, file1);
		iFile2 = repository.getIFile(iProject, file2);
	}

	@Test
	public void testSubscriber() throws Exception {
		GitResourceVariantTreeProvider provider = createTreeProvider();
		GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(provider);

		assertTrue(subscriber.isSupervised(iProject));
		assertTrue(subscriber.isSupervised(iFile1));
		assertTrue(subscriber.isSupervised(iFile2));

		assertSame(provider.getBaseTree(), subscriber.getBaseTree());
		assertSame(provider.getRemoteTree(), subscriber.getRemoteTree());
		assertSame(provider.getSourceTree(), subscriber.getSourceTree());

		assertNotNull(subscriber.getDiff(iProject));
		assertNotNull(subscriber.getDiff(iFile1));
		assertNotNull(subscriber.getDiff(iFile2));

		assertNotNull(subscriber.getSyncInfo(iProject));
		assertNotNull(subscriber.getSyncInfo(iFile1));
		assertNotNull(subscriber.getSyncInfo(iFile2));

	}

	@Test
	public void testSyncInfo() throws Exception {
		GitResourceVariantTreeProvider provider = createTreeProvider();
		GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(provider);

		final SyncInfo projectInfo = subscriber.getSyncInfo(iProject);
		assertNotNull(projectInfo);
		assertEquals(SyncInfo.CONFLICTING | SyncInfo.CHANGE, projectInfo.getKind());

		final SyncInfo syncInfo1 = subscriber.getSyncInfo(iFile1);
		assertNotNull(syncInfo1);
		assertEquals(SyncInfo.OUTGOING | SyncInfo.CHANGE, syncInfo1.getKind());
		IResourceVariant baseVariant1 = syncInfo1.getBase();
		IResourceVariant remoteVariant1 = syncInfo1.getRemote();
		assertContentEquals(baseVariant1, INITIAL_CONTENT_1);
		assertContentEquals(remoteVariant1, INITIAL_CONTENT_1);

		final SyncInfo syncInfo2 = subscriber.getSyncInfo(iFile2);
		assertNotNull(syncInfo2);
		assertEquals(SyncInfo.INCOMING | SyncInfo.CHANGE, syncInfo2.getKind());
		IResourceVariant baseVariant2 = syncInfo2.getBase();
		IResourceVariant remoteVariant2 = syncInfo2.getRemote();
		assertContentEquals(baseVariant2, INITIAL_CONTENT_2);
		assertContentEquals(remoteVariant2, BRANCH_CHANGES + INITIAL_CONTENT_2);
	}

	@Test
	public void testDiff() throws Exception {
		GitResourceVariantTreeProvider provider = createTreeProvider();
		GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(provider);

		final IDiff diff1 = subscriber.getDiff(iFile1);
		assertTrue(diff1 instanceof IThreeWayDiff);
		assertEquals(IDiff.CHANGE, diff1.getKind());
		assertEquals(IThreeWayDiff.OUTGOING, ((IThreeWayDiff)diff1).getDirection());
		final IDiff localDiff1 = ((IThreeWayDiff)diff1).getLocalChange();
		final IDiff remoteDiff1 = ((IThreeWayDiff)diff1).getRemoteChange();
		assertNull(remoteDiff1);
		assertTrue(localDiff1 instanceof ResourceDiff);
		final IFileRevision localState1 = ((ResourceDiff)localDiff1).getAfterState();
		final IFileRevision baseState1 = ((ResourceDiff)localDiff1).getBeforeState();
		assertNotNull(localState1);
		assertNotNull(baseState1);
		assertTrue(iFile1.getName().equals(localState1.getName()));
		assertTrue(iFile1.getName().equals(baseState1.getName()));
		final IStorage localStorage1 = localState1.getStorage(new NullProgressMonitor());
		final IStorage baseStorage1 = baseState1.getStorage(new NullProgressMonitor());
		assertContentEquals(localStorage1, INITIAL_CONTENT_1 + MASTER_CHANGES);
		assertContentEquals(baseStorage1, INITIAL_CONTENT_1);

		final IDiff diff2 = subscriber.getDiff(iFile2);
		assertTrue(diff2 instanceof IThreeWayDiff);
		assertEquals(IDiff.CHANGE, diff2.getKind());
		assertEquals(IThreeWayDiff.INCOMING, ((IThreeWayDiff)diff2).getDirection());
		final IDiff localDiff2 = ((IThreeWayDiff)diff2).getLocalChange();
		final IDiff remoteDiff2 = ((IThreeWayDiff)diff2).getRemoteChange();
		assertTrue(remoteDiff2 instanceof ResourceDiff);
		assertNull(localDiff2);
		final IFileRevision remoteState2 = ((ResourceDiff)remoteDiff2).getAfterState();
		final IFileRevision ancestorState2 = ((ResourceDiff)remoteDiff2).getBeforeState();
		assertTrue(iFile2.getName().equals(ancestorState2.getName()));
		assertTrue(iFile2.getName().equals(remoteState2.getName()));
		final IStorage ancestorStorage2 = ancestorState2.getStorage(new NullProgressMonitor());
		final IStorage remoteStorage2 = remoteState2.getStorage(new NullProgressMonitor());
		assertContentEquals(ancestorStorage2, INITIAL_CONTENT_2);
		assertContentEquals(remoteStorage2, BRANCH_CHANGES + INITIAL_CONTENT_2);
	}

	@Test
	public void testAddLocalAndRemote() throws Exception {
		GitResourceVariantTreeProvider provider = createTreeProviderWithAdditions();
		GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(provider);

		final IDiff diff1 = subscriber.getDiff(iFile1);
		assertTrue(diff1 instanceof IThreeWayDiff);
		assertEquals(IDiff.ADD, diff1.getKind());
		assertEquals(IThreeWayDiff.OUTGOING, ((IThreeWayDiff)diff1).getDirection());
		final IDiff localDiff1 = ((IThreeWayDiff)diff1).getLocalChange();
		final IDiff remoteDiff1 = ((IThreeWayDiff)diff1).getRemoteChange();
		assertTrue(localDiff1 instanceof ResourceDiff);
		assertNull(remoteDiff1);
		final IFileRevision ancestorState1 = ((ResourceDiff)localDiff1).getBeforeState();
		final IFileRevision localState1 = ((ResourceDiff)localDiff1).getAfterState();
		assertTrue(iFile1.getName().equals(localState1.getName()));
		assertNull(ancestorState1);
		final IStorage localStorage1 = localState1.getStorage(new NullProgressMonitor());
		assertContentEquals(localStorage1, INITIAL_CONTENT_1);

		final IDiff diff2 = subscriber.getDiff(iFile2);
		assertTrue(diff2 instanceof IThreeWayDiff);
		assertEquals(IDiff.ADD, diff2.getKind());
		assertEquals(IThreeWayDiff.INCOMING, ((IThreeWayDiff)diff2).getDirection());
		final IDiff localDiff2 = ((IThreeWayDiff)diff2).getLocalChange();
		final IDiff remoteDiff2 = ((IThreeWayDiff)diff2).getRemoteChange();
		assertTrue(remoteDiff2 instanceof ResourceDiff);
		assertNull(localDiff2);
		final IFileRevision ancestorState2 = ((ResourceDiff)remoteDiff2).getBeforeState();
		final IFileRevision remoteState2 = ((ResourceDiff)remoteDiff2).getAfterState();
		assertNull(ancestorState2);
		assertTrue(iFile2.getName().equals(remoteState2.getName()));
		final IStorage remoteStorage2 = remoteState2.getStorage(new NullProgressMonitor());
		assertContentEquals(remoteStorage2, INITIAL_CONTENT_2);
	}

	@Test
	public void testRemoveLocalAndRemote() throws Exception {
		GitResourceVariantTreeProvider provider = createTreeProviderWithDeletions();
		GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(provider);

		// file1 has been removed locally
		final IDiff diff1 = subscriber.getDiff(iFile1);
		assertTrue(diff1 instanceof IThreeWayDiff);
		assertEquals(IDiff.REMOVE, diff1.getKind());
		assertEquals(IThreeWayDiff.OUTGOING, ((IThreeWayDiff)diff1).getDirection());
		final IDiff localDiff1 = ((IThreeWayDiff)diff1).getLocalChange();
		final IDiff remoteDiff1 = ((IThreeWayDiff)diff1).getRemoteChange();
		assertTrue(localDiff1 instanceof ResourceDiff);
		assertNull(remoteDiff1);
		final IFileRevision ancestorState1 = ((ResourceDiff)localDiff1).getBeforeState();
		final IFileRevision localState1 = ((ResourceDiff)localDiff1).getAfterState();
		assertTrue(iFile1.getName().equals(ancestorState1.getName()));
		assertNull(localState1);
		final IStorage ancestorStorage1 = ancestorState1.getStorage(new NullProgressMonitor());
		assertContentEquals(ancestorStorage1, INITIAL_CONTENT_1);

		// file2 has been removed remotely
		final IDiff diff2 = subscriber.getDiff(iFile2);
		assertTrue(diff2 instanceof IThreeWayDiff);
		assertEquals(IDiff.REMOVE, diff2.getKind());
		assertEquals(IThreeWayDiff.INCOMING, ((IThreeWayDiff)diff2).getDirection());
		final IDiff localDiff2 = ((IThreeWayDiff)diff2).getLocalChange();
		final IDiff remoteDiff2 = ((IThreeWayDiff)diff2).getRemoteChange();
		assertTrue(remoteDiff2 instanceof ResourceDiff);
		assertNull(localDiff2);
		final IFileRevision ancestorState2 = ((ResourceDiff)remoteDiff2).getBeforeState();
		final IFileRevision remoteState2 = ((ResourceDiff)remoteDiff2).getAfterState();
		assertTrue(iFile2.getName().equals(ancestorState2.getName()));
		assertNull(remoteState2);
		final IStorage rancestorStorage2 = ancestorState2.getStorage(new NullProgressMonitor());
		assertContentEquals(rancestorStorage2, INITIAL_CONTENT_2);
	}

	private GitResourceVariantTreeProvider createTreeProvider() throws Exception {
		repository.appendContentAndCommit(iProject, file1, INITIAL_CONTENT_1, "first file - initial commit");
		repository.appendContentAndCommit(iProject, file2, INITIAL_CONTENT_2, "second file - initial commit");
		repository.createBranch(MASTER, BASE);

		repository.createAndCheckoutBranch(MASTER, BRANCH);

		setContentsAndCommit(repository, iFile2, BRANCH_CHANGES + INITIAL_CONTENT_2, "branch commit");

		repository.checkoutBranch(MASTER);

		setContentsAndCommit(repository, iFile1, INITIAL_CONTENT_1 + MASTER_CHANGES, "master commit");
		iProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());

		// as if we tried to merge branch into master
		RevWalk walk = new RevWalk(repo);
		try {
			RevTree baseTree = walk.parseTree(repo.resolve(BASE));
			RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
			RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
			TreeWalk treeWalk = new NameConflictTreeWalk(repo);
			treeWalk.addTree(baseTree);
			treeWalk.addTree(sourceTree);
			treeWalk.addTree(remoteTree);
			return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
		} finally {
			walk.close();
		}
	}

	private GitResourceVariantTreeProvider createTreeProviderWithAdditions() throws Exception {
		repository.createBranch(MASTER, BASE);
		repository.createAndCheckoutBranch(MASTER, BRANCH);
		file2 = repository.createFile(iProject, "file2");
		repository.appendContentAndCommit(iProject, file2, INITIAL_CONTENT_2,
				"Creation of file2 in branch2.");

		repository.checkoutBranch(MASTER);
		file1 = repository.createFile(iProject, "file1");
		repository.appendContentAndCommit(iProject, file1, INITIAL_CONTENT_1,
				"Creation of file1 in branch1.");

		iProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());

		// as if we tried to merge branch3 into branch2
		RevWalk walk = new RevWalk(repo);
		try {
			RevTree baseTree = walk.parseTree(repo.resolve(BASE));
			RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
			RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
			TreeWalk treeWalk = new NameConflictTreeWalk(repo);
			treeWalk.addTree(baseTree);
			treeWalk.addTree(sourceTree);
			treeWalk.addTree(remoteTree);
			return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
		} finally {
			walk.close();
		}
	}

	private GitResourceVariantTreeProvider createTreeProviderWithDeletions() throws Exception {
		file1 = repository.createFile(iProject, "file1");
		repository.appendContentAndCommit(iProject, file1, INITIAL_CONTENT_1,
				"Creation of file1 in branch1.");
		file2 = repository.createFile(iProject, "file2");
		repository.appendContentAndCommit(iProject, file2, INITIAL_CONTENT_2,
				"Creation of file2 in branch2.");
		repository.createBranch(MASTER, BASE);

		repository.createAndCheckoutBranch(MASTER, BRANCH);
		repository.untrack(file2);
		repository.commit("Removed file2 in branch.");

		repository.checkoutBranch(MASTER);
		repository.untrack(file1);
		repository.commit("Removed file1 in master.");

		iProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());

		// as if we tried to merge branch3 into branch2
		RevWalk walk = new RevWalk(repo);
		try {
			RevTree baseTree = walk.parseTree(repo.resolve(BASE));
			RevTree sourceTree = walk.parseTree(repo.resolve(MASTER));
			RevTree remoteTree = walk.parseTree(repo.resolve(BRANCH));
			TreeWalk treeWalk = new NameConflictTreeWalk(repo);
			treeWalk.addTree(baseTree);
			treeWalk.addTree(sourceTree);
			treeWalk.addTree(remoteTree);
			return new TreeWalkResourceVariantTreeProvider(repo, treeWalk, 0, 1, 2);
		} finally {
			walk.close();
		}
	}
}