Java tutorial
/******************************************************************************* * Copyright (C) 2011, Dariusz Luksza <dariusz@luksza.org> * * 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.egit.core.synchronize; import static org.eclipse.egit.core.synchronize.GitCommitsModelCache.ADDITION; import static org.eclipse.egit.core.synchronize.GitCommitsModelCache.CHANGE; import static org.eclipse.egit.core.synchronize.GitCommitsModelCache.DELETION; import static org.eclipse.egit.core.synchronize.GitCommitsModelCache.LEFT; import static org.eclipse.egit.core.synchronize.GitCommitsModelCache.RIGHT; import static org.eclipse.jgit.junit.JGitTestUtil.deleteTrashFile; import static org.eclipse.jgit.junit.JGitTestUtil.writeTrashFile; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.not; import static org.hamcrest.CoreMatchers.notNullValue; import static org.hamcrest.Matchers.nullValue; import static org.junit.Assert.assertThat; import java.io.IOException; import java.util.List; import org.eclipse.egit.core.synchronize.GitCommitsModelCache.Change; import org.eclipse.egit.core.synchronize.GitCommitsModelCache.Commit; import org.eclipse.jgit.api.Git; import org.eclipse.jgit.errors.AmbiguousObjectException; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.treewalk.filter.PathFilter; import org.junit.Test; @SuppressWarnings("boxing") public class GitCommitsModelCacheTest extends AbstractCacheTest { @Test public void shouldReturnEmptyListForSameSrcAndDstCommit() throws Exception { // given Git git = new Git(db); RevCommit c = commit(git, "second commit"); // when List<Commit> result = GitCommitsModelCache.build(db, c, c, null); // then assertThat(result, notNullValue()); assertThat(result.size(), is(0)); } @Test public void shouldNotListEmptyCommits() throws Exception { // given Git git = new Git(db); RevCommit c = commit(git, "second commit"); // when List<Commit> result = GitCommitsModelCache.build(db, initialTagId(), c, null); // then assertThat(result, notNullValue()); assertThat(result.size(), is(0)); } @Test public void shouldListAdditionOrDeletionInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "a.txt", "content"); git.add().addFilepattern("a.txt").call(); RevCommit c = commit(git, "first commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, initialTagId(), c, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c, initialTagId(), null); // then // left assertions assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c, 1); assertFileDeletion(c, leftResult.get(0).getChildren().get("a.txt"), "a.txt", LEFT); // right asserts, after changing sides addition becomes deletion assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c, 1); assertFileAddition(c, rightResult.get(0).getChildren().get("a.txt"), "a.txt", RIGHT); } @Test public void shouldListAdditionOrDeletionInsideFolderInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); git.add().addFilepattern("folder/a.txt").call(); RevCommit c = commit(git, "first commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, initialTagId(), c, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c, initialTagId(), null); // then // left assertions assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c, 1); assertThat(leftResult.get(0).getChildren().size(), is(1)); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); // right asserts, after changing sides addition becomes deletion assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c, 1); assertThat(rightResult.get(0).getChildren().size(), is(1)); assertFileAddition(c, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); } @Test public void shouldListAdditionsOrDeletionsInsideSeparateFoldersInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); writeTrashFile(db, "folder2/b.txt", "b content"); git.add().addFilepattern("folder/a.txt").call(); git.add().addFilepattern("folder2/b.txt").call(); RevCommit c = commit(git, "first commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, initialTagId(), c, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c, initialTagId(), null); // then // left assertions assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertThat(leftResult.get(0).getShortMessage(), is("first commit")); assertThat(leftResult.get(0).getChildren(), notNullValue()); assertThat(leftResult.get(0).getChildren().size(), is(2)); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder2/b.txt"), "b.txt", LEFT); // right asserts, after changing sides addition becomes deletion assertThat(rightResult, notNullValue()); assertThat(Integer.valueOf(rightResult.size()), is(Integer.valueOf(1))); assertThat(rightResult.get(0).getShortMessage(), is("first commit")); assertThat(rightResult.get(0).getChildren(), notNullValue()); assertThat(rightResult.get(0).getChildren().size(), is(2)); assertFileAddition(c, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileAddition(c, rightResult.get(0).getChildren().get("folder2/b.txt"), "b.txt", RIGHT); } @Test public void shouldApplyPathFilter() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); writeTrashFile(db, "folder2/b.txt", "b content"); git.add().addFilepattern("folder/a.txt").call(); git.add().addFilepattern("folder2/b.txt").call(); RevCommit c = commit(git, "first commit"); // when PathFilter pathFilter = PathFilter.create("folder"); List<Commit> leftResult = GitCommitsModelCache.build(db, initialTagId(), c, pathFilter); // then assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertThat(leftResult.get(0).getShortMessage(), is("first commit")); assertThat(leftResult.get(0).getChildren(), notNullValue()); assertThat(leftResult.get(0).getChildren().size(), is(1)); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); } @Test public void shouldListAdditionsOrDeletionsInsideFolderInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); writeTrashFile(db, "folder/b.txt", "b content"); git.add().addFilepattern("folder").call(); RevCommit c = commit(git, "first commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, initialTagId(), c, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c, initialTagId(), null); // then // left assertions assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertCommit(leftResult.get(0), c, 2); assertThat(leftResult.get(0).getChildren().size(), is(2)); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileDeletion(c, leftResult.get(0).getChildren().get("folder/b.txt"), "b.txt", LEFT); // right asserts, after changing sides addition becomes deletion assertThat(rightResult, notNullValue()); assertThat(Integer.valueOf(rightResult.size()), is(Integer.valueOf(1))); assertCommit(rightResult.get(0), c, 2); assertThat(rightResult.get(0).getChildren().size(), is(2)); assertFileAddition(c, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileAddition(c, rightResult.get(0).getChildren().get("folder/b.txt"), "b.txt", RIGHT); } @Test public void shouldListChangeInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "a.txt", "content"); git.add().addFilepattern("a.txt").call(); RevCommit c1 = commit(git, "first commit"); writeTrashFile(db, "a.txt", "new content"); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c2, 1); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("a.txt"), "a.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c2, 1); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("a.txt"), "a.txt", RIGHT); } @Test public void shouldListChangeInsideFolderInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); git.add().addFilepattern("folder/a.txt").call(); RevCommit c1 = commit(git, "first commit"); writeTrashFile(db, "folder/a.txt", "new content"); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c2, 1); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c2, 1); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); } @Test public void shouldListChangesInsideSeparateFoldersInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); writeTrashFile(db, "folder2/b.txt", "b content"); git.add().addFilepattern("folder/a.txt").call(); git.add().addFilepattern("folder2/b.txt").call(); RevCommit c1 = commit(git, "first commit"); writeTrashFile(db, "folder/a.txt", "new content"); writeTrashFile(db, "folder2/b.txt", "new b content"); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertThat(leftResult.get(0).getShortMessage(), is("second commit")); assertThat(leftResult.get(0).getChildren(), notNullValue()); assertThat(leftResult.get(0).getChildren().size(), is(2)); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder2/b.txt"), "b.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertThat(Integer.valueOf(rightResult.size()), is(Integer.valueOf(1))); assertThat(rightResult.get(0).getShortMessage(), is("second commit")); assertThat(rightResult.get(0).getChildren().size(), is(2)); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder2/b.txt"), "b.txt", RIGHT); } @Test public void shouldListChangesInsideFolderInCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "content"); writeTrashFile(db, "folder/b.txt", "b content"); git.add().addFilepattern("folder").call(); RevCommit c1 = commit(git, "first commit"); writeTrashFile(db, "folder/a.txt", "new content"); writeTrashFile(db, "folder/b.txt", "new b content"); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertCommit(leftResult.get(0), c2, 2); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder/b.txt"), "b.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertThat(Integer.valueOf(rightResult.size()), is(Integer.valueOf(1))); assertCommit(rightResult.get(0), c2, 2); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder/b.txt"), "b.txt", RIGHT); } @Test public void shouldListAllTypeOfChangesInOneCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "a.txt", "a content"); writeTrashFile(db, "c.txt", "c content"); git.add().addFilepattern("a.txt").call(); git.add().addFilepattern("c.txt").call(); RevCommit c1 = commit(git, "first commit"); deleteTrashFile(db, "a.txt"); writeTrashFile(db, "b.txt", "b content"); writeTrashFile(db, "c.txt", "new c content"); git.add().addFilepattern("b.txt").call(); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left asserts assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c2, 3); assertFileAddition(c1, c2, leftResult.get(0).getChildren().get("a.txt"), "a.txt", LEFT); assertFileDeletion(c1, c2, leftResult.get(0).getChildren().get("b.txt"), "b.txt", LEFT); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("c.txt"), "c.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c2, 3); assertFileDeletion(c2, c1, rightResult.get(0).getChildren().get("a.txt"), "a.txt", RIGHT); assertFileAddition(c2, c1, rightResult.get(0).getChildren().get("b.txt"), "b.txt", RIGHT); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("c.txt"), "c.txt", RIGHT); } @Test public void shouldListAllTypeOfChangesInsideFolderInOneCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "a content"); writeTrashFile(db, "folder/c.txt", "c content"); git.add().addFilepattern("folder/a.txt").call(); git.add().addFilepattern("folder/c.txt").call(); RevCommit c1 = commit(git, "first commit"); deleteTrashFile(db, "folder/a.txt"); writeTrashFile(db, "folder/b.txt", "b content"); writeTrashFile(db, "folder/c.txt", "new c content"); git.add().addFilepattern("folder/b.txt").call(); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertCommit(leftResult.get(0), c2, 3); assertFileAddition(c1, c2, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileDeletion(c1, c2, leftResult.get(0).getChildren().get("folder/b.txt"), "b.txt", LEFT); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder/c.txt"), "c.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertCommit(rightResult.get(0), c2, 3); assertFileDeletion(c2, c1, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileAddition(c2, c1, rightResult.get(0).getChildren().get("folder/b.txt"), "b.txt", RIGHT); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder/c.txt"), "c.txt", RIGHT); } @Test public void shouldListAllTypeOfChangesInsideSeparateFoldersInOneCommit() throws Exception { // given Git git = new Git(db); writeTrashFile(db, "folder/a.txt", "a content"); writeTrashFile(db, "folder2/c.txt", "c content"); git.add().addFilepattern("folder/a.txt").call(); git.add().addFilepattern("folder2/c.txt").call(); RevCommit c1 = commit(git, "first commit"); deleteTrashFile(db, "folder/a.txt"); writeTrashFile(db, "folder1/b.txt", "b content"); writeTrashFile(db, "folder2/c.txt", "new c content"); git.add().addFilepattern("folder1/b.txt").call(); RevCommit c2 = commit(git, "second commit"); // when List<Commit> leftResult = GitCommitsModelCache.build(db, c1, c2, null); List<Commit> rightResult = GitCommitsModelCache.build(db, c2, c1, null); // then // left assertions assertThat(leftResult, notNullValue()); assertThat(Integer.valueOf(leftResult.size()), is(Integer.valueOf(1))); assertThat(leftResult.get(0).getShortMessage(), is("second commit")); assertThat(leftResult.get(0).getChildren(), notNullValue()); assertThat(leftResult.get(0).getChildren().size(), is(3)); assertFileAddition(c1, c2, leftResult.get(0).getChildren().get("folder/a.txt"), "a.txt", LEFT); assertFileDeletion(c1, c2, leftResult.get(0).getChildren().get("folder1/b.txt"), "b.txt", LEFT); assertFileChange(c1, c2, leftResult.get(0).getChildren().get("folder2/c.txt"), "c.txt", LEFT); // right asserts assertThat(rightResult, notNullValue()); assertThat(Integer.valueOf(rightResult.size()), is(Integer.valueOf(1))); assertThat(rightResult.get(0).getShortMessage(), is("second commit")); assertThat(rightResult.get(0).getChildren(), notNullValue()); assertThat(rightResult.get(0).getChildren().size(), is(3)); assertFileDeletion(c2, c1, rightResult.get(0).getChildren().get("folder/a.txt"), "a.txt", RIGHT); assertFileAddition(c2, c1, rightResult.get(0).getChildren().get("folder1/b.txt"), "b.txt", RIGHT); assertFileChange(c2, c1, rightResult.get(0).getChildren().get("folder2/c.txt"), "c.txt", RIGHT); } private RevCommit commit(Git git, String msg) throws Exception { tick(); return git.commit().setAll(true).setMessage(msg).setCommitter(committer).call(); } private ObjectId initialTagId() throws AmbiguousObjectException, IOException { return db.resolve(INITIAL_TAG); } private void assertCommit(Commit commit, RevCommit actualCommit, int childrenCount) { commonCommitAsserts(commit, actualCommit); assertThat(commit.getChildren(), notNullValue()); assertThat(commit.getChildren().size(), is(childrenCount)); } private void commonCommitAsserts(Commit commit, RevCommit actualCommit) { assertThat(commit.getShortMessage(), is(actualCommit.getShortMessage())); assertThat(commit.getId().toObjectId(), is(actualCommit.getId())); assertThat(commit.getAuthorName(), is(actualCommit.getAuthorIdent().getName())); assertThat(commit.getCommitterName(), is(actualCommit.getCommitterIdent().getName())); assertThat(commit.getCommitDate(), is(actualCommit.getAuthorIdent().getWhen())); } private void assertFileChange(RevCommit actual, RevCommit parent, Change change, String name, int direction) { commonFileAssertions(actual, parent, change, name); assertThat(change.getObjectId(), not(ZERO_ID)); assertThat(change.getRemoteObjectId(), not(ZERO_ID)); if (direction == LEFT) assertThat(change.getKind(), is(LEFT | CHANGE)); else assertThat(change.getKind(), is(RIGHT | CHANGE)); } private void assertFileAddition(RevCommit actual, Change change, String name, int direction) { assertFileAddition(actual, null, change, name, direction); } private void assertFileAddition(RevCommit actual, RevCommit parent, Change change, String name, int direction) { commonFileAssertions(actual, parent, change, name); if (direction == LEFT) { assertThat(change.getKind(), is(LEFT | ADDITION)); assertThat(change.getRemoteCommitId(), not(ZERO_ID)); assertThat(change.getObjectId(), nullValue()); } else { // should be Differencer.Right assertThat(change.getKind(), is(RIGHT | ADDITION)); assertThat(change.getObjectId(), not(ZERO_ID)); assertThat(change.getRemoteObjectId(), nullValue()); } } private void assertFileDeletion(RevCommit parent, Change change, String name, int direction) { assertFileDeletion(null, parent, change, name, direction); } private void assertFileDeletion(RevCommit actual, RevCommit parent, Change change, String name, int direction) { commonFileAssertions(actual, parent, change, name); if (direction == LEFT) { assertThat(change.getRemoteObjectId(), nullValue()); assertThat(change.getObjectId(), not(ZERO_ID)); assertThat(change.getKind(), is(LEFT | DELETION)); } else { // should be Differencer.Right assertThat(change.getKind(), is(RIGHT | DELETION)); assertThat(change.getObjectId(), nullValue()); assertThat(change.getRemoteObjectId(), not(ZERO_ID)); } } private void commonFileAssertions(RevCommit actual, RevCommit parent, Change change, String name) { assertThat(change, notNullValue()); if (parent != null) assertThat(change.getRemoteCommitId().toObjectId(), is(parent.getId())); if (actual != null && !ObjectId.zeroId().equals(actual)) assertThat(change.getCommitId().toObjectId(), is(actual.getId())); assertThat(change.getName(), is(name)); } }