Examples with GitSynchronizeData org.eclipse.egit.core.synchronize.dto.GitSynchronizeData used on opensource projects

Example 26 with GitSynchronizeData

use of org.eclipse.egit.core.synchronize.dto.GitSynchronizeData in project egit by eclipse.

the class GitResourceVariantTreeTest method shouldNotReturnNullOnSameResouceVariant.

@Test
public void shouldNotReturnNullOnSameResouceVariant() throws Exception {
    String modifiedFileName = "changingFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    String unchangedFileName = "notChangingFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    String removedFileName = "toBeRemovedFile." + SampleModelProvider.SAMPLE_FILE_EXTENSION;
    File modifiedFile = testRepo.createFile(iProject, modifiedFileName);
    File unchangedFile = testRepo.createFile(iProject, unchangedFileName);
    File removedFile = testRepo.createFile(iProject, removedFileName);
    testRepo.appendFileContent(modifiedFile, "My content is changing");
    testRepo.appendFileContent(unchangedFile, "My content is constant");
    testRepo.appendFileContent(removedFile, "I will be removed");
    IFile iModifiedFile = testRepo.getIFile(iProject, modifiedFile);
    IFile iUnchangedFile = testRepo.getIFile(iProject, unchangedFile);
    IFile iRemovedFile = testRepo.getIFile(iProject, removedFile);
    testRepo.trackAllFiles(iProject);
    RevCommit firstCommit = testRepo.commit("C1");
    testRepo.appendFileContent(modifiedFile, " My content has changed");
    testRepo.track(modifiedFile);
    testRepo.removeFromIndex(removedFile);
    RevCommit secondCommit = testRepo.commit("C2");
    // @formatter:off
    // History (X means has changed)
    // ------------------------------------------------------------
    // files					   C1 [HEAD]		  	C2
    // changingFile.sample   	|-----X----------|-------X-------|->
    // notChangingFile.sample	|-----X----------|---------------|->
    // toBeRemovedFile.sample	|-----X----------|-------X-------|->
    // -------------------------------------------------------------
    // @formatter:on
    testRepo.checkoutBranch(firstCommit.getName());
    iProject.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
    // Now synchronize the two commits using our logical model provider
    SampleModelProvider provider = new SampleModelProvider();
    // Get the affected resources
    ResourceMapping[] mappings = provider.getMappings(iModifiedFile, ResourceMappingContext.LOCAL_CONTEXT, new NullProgressMonitor());
    Set<IResource> includedResource = collectResources(mappings);
    Set<IResource> expectedIncludedResources = new HashSet<IResource>();
    expectedIncludedResources.add(iModifiedFile);
    expectedIncludedResources.add(iUnchangedFile);
    expectedIncludedResources.add(iRemovedFile);
    assertEquals(expectedIncludedResources, includedResource);
    // Synchronize the data
    final GitSynchronizeData data = new GitSynchronizeData(testRepo.getRepository(), firstCommit.getName(), secondCommit.getName(), true, includedResource);
    GitSynchronizeDataSet gitSynchDataSet = new GitSynchronizeDataSet(data);
    final GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(gitSynchDataSet);
    subscriber.init(new NullProgressMonitor());
    IResourceVariantTree sourceVariantTree = subscriber.getSourceTree();
    assertNotNull(sourceVariantTree);
    IResourceVariantTree remoteVariantTree = subscriber.getRemoteTree();
    assertNotNull(remoteVariantTree);
    // In the use case in which the file has been deleted the source variant is
    // not null whereas the remote variant is null.It seems quite logic.
    // However in the second use case we have the same result, the source variant is
    // not null whereas the remote is null. In both cases the null value does
    // not mean the same thing. In the first case, the null value means that
    // the resource is no longer in the repository and in the second the
    // null value means there is no change between the two versions.
    // Using these values I am not able to distinguish both case.
    // It is in contradiction with test #shouldReturnNullResourceVariant2()
    // and test #shoulReturnSameResourceVariant(). However I haven't found
    // another way to handle this case. Maybe something can be
    // done with ThreeWayDiffEntry.scan(tw) to force including in the cache
    // some entry even if they have not changed. For example,
    // ThreeWayDiffEntry.scan(tw,includedSource) or maybe try preventing the variant
    // tree to return null by walking throught the repository and looking for the file...
    IResourceVariant unchangedSourceVariant = sourceVariantTree.getResourceVariant(iUnchangedFile);
    IResourceVariant unchangedRemoteVariant = remoteVariantTree.getResourceVariant(iUnchangedFile);
    assertNotNull(unchangedSourceVariant);
    assertNotNull(unchangedRemoteVariant);
    IResourceVariant removedSourceVariant = sourceVariantTree.getResourceVariant(iRemovedFile);
    IResourceVariant removedRemoteVariant = remoteVariantTree.getResourceVariant(iRemovedFile);
    assertNotNull(removedSourceVariant);
    assertNull(removedRemoteVariant);
    GitSubscriberResourceMappingContext context = new GitSubscriberResourceMappingContext(subscriber, gitSynchDataSet);
    assertFalse(context.hasLocalChange(iUnchangedFile, new NullProgressMonitor()));
    assertFalse(context.hasRemoteChange(iUnchangedFile, new NullProgressMonitor()));
    assertFalse(context.hasLocalChange(iModifiedFile, new NullProgressMonitor()));
    assertTrue(context.hasRemoteChange(iModifiedFile, new NullProgressMonitor()));
    assertFalse(context.hasLocalChange(iRemovedFile, new NullProgressMonitor()));
    assertTrue(context.hasRemoteChange(iRemovedFile, new NullProgressMonitor()));
}

Example 27 with GitSynchronizeData

use of org.eclipse.egit.core.synchronize.dto.GitSynchronizeData in project egit by eclipse.

the class GitResourceVariantTreeTest method shouldReturnDifferentResourceVariant.

/**
 * Create and commit Main.java file in master branch, then create branch
 * "test" checkout nearly created branch and modify Main.java file.
 * getResourceVariant() should obtain Main.java file content from "master"
 * branch. Passes only when it is run as a single test, not as a part of
 * largest test suite
 *
 * @throws Exception
 */
@Test
public void shouldReturnDifferentResourceVariant() throws Exception {
    // when
    String fileName = "Main.java";
    File file = testRepo.createFile(iProject, fileName);
    testRepo.appendContentAndCommit(iProject, file, "class Main {}", "initial commit");
    IFile mainJava = testRepo.getIFile(iProject, file);
    testRepo.createAndCheckoutBranch(Constants.R_HEADS + Constants.MASTER, Constants.R_HEADS + "test");
    testRepo.appendContentAndCommit(iProject, file, "// test", "first commit");
    GitSynchronizeData data = new GitSynchronizeData(repo, HEAD, MASTER, true);
    GitSynchronizeDataSet dataSet = new GitSynchronizeDataSet(data);
    GitSyncCache cache = GitSyncCache.getAllData(dataSet, new NullProgressMonitor());
    // given
    GitResourceVariantTree grvt = new GitBaseResourceVariantTree(cache, dataSet);
    // then
    IResourceVariant actual = grvt.getResourceVariant(mainJava);
    assertNotNull(actual);
    assertEquals(fileName, actual.getName());
    InputStream actualIn = actual.getStorage(new NullProgressMonitor()).getContents();
    byte[] actualByte = getBytesAndCloseStream(actualIn);
    InputStream expectedIn = mainJava.getContents();
    byte[] expectedByte = getBytesAndCloseStream(expectedIn);
    // assert arrays not equals
    assertFalse(Arrays.equals(expectedByte, actualByte));
}

Example 28 with GitSynchronizeData

use of org.eclipse.egit.core.synchronize.dto.GitSynchronizeData in project egit by eclipse.

the class HistoryTest method queryHistoryThroughTeam.

/*
	 * This aims at exerting the behavior of the EGit history provider when used
	 * through the Team APIs. This is the behavior extenders will see when
	 * interfacing with EGit through the synchronize view.
	 *
	 * The exact comparison with which we've reached the synchronize perspective
	 * should not be relevant. To keep this test as short as possible, we'll
	 * only test a single comparison.
	 */
@Test
public void queryHistoryThroughTeam() throws IOException, CoreException {
    GitSynchronizeData gsd = new GitSynchronizeData(testRepository.getRepository(), MASTER, BRANCH, false);
    GitSynchronizeDataSet gsds = new GitSynchronizeDataSet(gsd);
    GitResourceVariantTreeSubscriber subscriber = new GitResourceVariantTreeSubscriber(gsds);
    subscriber.init(new NullProgressMonitor());
    IDiff diff = subscriber.getDiff(iFile2);
    assertTrue(diff instanceof IThreeWayDiff);
    IFileRevision sourceRevision = getSource(diff);
    IFileRevision destinationRevision = getDestination(diff);
    IFileRevision baseRevision = getBase(diff);
    assertRevisionMatchCommit(baseRevision, masterCommit2);
    assertRevisionMatchCommit(destinationRevision, branchCommit2);
    assertRevisionMatchCommit(sourceRevision, masterCommit3);
    final IFileHistory history = historyProvider.getFileHistoryFor(iFile2, IFileHistoryProvider.NONE, new NullProgressMonitor());
    assertNotNull(history);
    // no parent of masterCommit2 in file2's history
    IFileRevision[] parents = history.getContributors(baseRevision);
    assertEquals(0, parents.length);
    /*
		 * branchCommit1 did not contain file2, so the "child" of masterCommit2
		 * (branching point) in file2's history is branchCommit2.
		 */
    IFileRevision[] children = history.getTargets(baseRevision);
    List<RevCommit> expectedChildren = new ArrayList<RevCommit>(Arrays.asList(masterCommit3, branchCommit2));
    assertEquals(expectedChildren.size(), children.length);
    assertMatchingRevisions(Arrays.asList(children), expectedChildren);
}

Example 29 with GitSynchronizeData

use of org.eclipse.egit.core.synchronize.dto.GitSynchronizeData in project egit by eclipse.

the class GitResourceVariantTreeTest method shouldReturnOneRoot.

/**
 * roots() method should return list of projects that are associated with
 * given repository. In this case there is only one project associated with
 * this repository therefore only one root should be returned.
 *
 * @throws Exception
 */
@Test
public void shouldReturnOneRoot() throws Exception {
    // when
    try (Git git = new Git(repo)) {
        git.commit().setAuthor("JUnit", "junit@egit.org").setMessage("Initial commit").call();
    }
    GitSynchronizeData data = new GitSynchronizeData(repo, HEAD, HEAD, false);
    GitSynchronizeDataSet dataSet = new GitSynchronizeDataSet(data);
    // given
    GitResourceVariantTree grvt = new GitTestResourceVariantTree(dataSet, null, null);
    // then
    assertEquals(1, grvt.roots().length);
    IResource actualProject = grvt.roots()[0];
    assertEquals(this.project.getProject(), actualProject);
}

Example 30 with GitSynchronizeData

use of org.eclipse.egit.core.synchronize.dto.GitSynchronizeData in project egit by eclipse.

the class AbstractSynchronizeViewTest method launchSynchronization.

protected void launchSynchronization(String projectName, String srcRef, String dstRef, boolean includeLocal) throws IOException {
    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
    RepositoryMapping mapping = assertConnected(project);
    Repository repo = mapping.getRepository();
    GitSynchronizeData data = new GitSynchronizeData(repo, srcRef, dstRef, includeLocal);
    JobJoiner jobJoiner = JobJoiner.startListening(ISynchronizeManager.FAMILY_SYNCHRONIZE_OPERATION, 60, TimeUnit.SECONDS);
    GitModelSynchronize.launch(data, new IResource[] { project });
    jobJoiner.join();
}