Merged in feature/merge_api (pull request #106)

Feature merge api

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/CloseableWrapperTest.java

@@ -0,0 +1,29 @@
+package sonia.scm.repository;
+
+import org.junit.Test;
+
+import java.util.function.Consumer;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+public class CloseableWrapperTest {
+
+  @Test
+  public void shouldExecuteGivenMethodAtClose() {
+    Consumer<String> wrapped = new Consumer<String>() {
+      // no this cannot be replaced with a lambda because otherwise we could not use Mockito#spy
+      @Override
+      public void accept(String s) {
+      }
+    };
+
+    Consumer<String> closer = spy(wrapped);
+
+    try (CloseableWrapper<String> wrapper = new CloseableWrapper<>("test", closer)) {
+      // nothing to do here
+    }
+
+    verify(closer).accept("test");
+  }
+}

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/GitRepositoryHandlerTest.java

@@ -61,6 +61,9 @@ public class GitRepositoryHandlerTest extends SimpleRepositoryHandlerTestBase {
   @Mock
   private ConfigurationStoreFactory factory;
 
+  @Mock
+  private GitWorkdirFactory gitWorkdirFactory;
+
   @Override
   protected void checkDirectory(File directory) {
     File head = new File(directory, "HEAD");
@@ -84,7 +87,7 @@ public class GitRepositoryHandlerTest extends SimpleRepositoryHandlerTestBase {
   protected RepositoryHandler createRepositoryHandler(ConfigurationStoreFactory factory,
                                                       File directory) {
     GitRepositoryHandler repositoryHandler = new GitRepositoryHandler(factory,
-      new DefaultFileSystem(), scheduler);
+      new DefaultFileSystem(), scheduler, gitWorkdirFactory);
 
     repositoryHandler.init(contextProvider);
 
@@ -100,7 +103,7 @@ public class GitRepositoryHandlerTest extends SimpleRepositoryHandlerTestBase {
   @Test
   public void getDirectory() {
     GitRepositoryHandler repositoryHandler = new GitRepositoryHandler(factory,
-      new DefaultFileSystem(), scheduler);
+      new DefaultFileSystem(), scheduler, gitWorkdirFactory);
 
     GitConfig gitConfig = new GitConfig();
     gitConfig.setRepositoryDirectory(new File("/path"));

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/AbstractGitCommandTestBase.java

@@ -50,7 +50,9 @@ public class AbstractGitCommandTestBase extends ZippedRepositoryTestBase
   @After
   public void close()
   {
-    context.close();
+    if (context != null) {
+      context.close();
+    }
   }
 
   /**

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/GitMergeCommandTest.java

@@ -0,0 +1,139 @@
+package sonia.scm.repository.spi;
+
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+import org.apache.shiro.subject.SimplePrincipalCollection;
+import org.apache.shiro.subject.Subject;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.junit.Rule;
+import org.junit.Test;
+import sonia.scm.repository.Person;
+import sonia.scm.repository.api.MergeCommandResult;
+import sonia.scm.user.User;
+
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SubjectAware(configuration = "classpath:sonia/scm/configuration/shiro.ini")
+public class GitMergeCommandTest extends AbstractGitCommandTestBase {
+
+  private static final String REALM = "AdminRealm";
+
+  @Rule
+  public ShiroRule shiro = new ShiroRule();
+
+  @Test
+  public void shouldDetectMergeableBranches() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setBranchToMerge("mergeable");
+    request.setTargetBranch("master");
+
+    boolean mergeable = command.dryRun(request).isMergeable();
+
+    assertThat(mergeable).isTrue();
+  }
+
+  @Test
+  public void shouldDetectNotMergeableBranches() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setBranchToMerge("test-branch");
+    request.setTargetBranch("master");
+
+    boolean mergeable = command.dryRun(request).isMergeable();
+
+    assertThat(mergeable).isFalse();
+  }
+
+  @Test
+  public void shouldMergeMergeableBranches() throws IOException, GitAPIException {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("master");
+    request.setBranchToMerge("mergeable");
+    request.setAuthor(new Person("Dirk Gently", "dirk@holistic.det"));
+
+    MergeCommandResult mergeCommandResult = command.merge(request);
+
+    assertThat(mergeCommandResult.isSuccess()).isTrue();
+
+    Repository repository = createContext().open();
+    Iterable<RevCommit> commits = new Git(repository).log().add(repository.resolve("master")).setMaxCount(1).call();
+    RevCommit mergeCommit = commits.iterator().next();
+    PersonIdent mergeAuthor = mergeCommit.getAuthorIdent();
+    String message = mergeCommit.getFullMessage();
+    assertThat(mergeAuthor.getName()).isEqualTo("Dirk Gently");
+    assertThat(mergeAuthor.getEmailAddress()).isEqualTo("dirk@holistic.det");
+    assertThat(message).contains("master", "mergeable");
+    // We expect the merge result of file b.txt here by looking up the sha hash of its content.
+    // If the file is missing (aka not merged correctly) this will throw a MissingObjectException:
+    byte[] contentOfFileB = repository.open(repository.resolve("9513e9c76e73f3e562fd8e4c909d0607113c77c6")).getBytes();
+    assertThat(new String(contentOfFileB)).isEqualTo("b\ncontent from branch\n");
+  }
+
+  @Test
+  public void shouldUseConfiguredCommitMessageTemplate() throws IOException, GitAPIException {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("master");
+    request.setBranchToMerge("mergeable");
+    request.setAuthor(new Person("Dirk Gently", "dirk@holistic.det"));
+    request.setMessageTemplate("simple");
+
+    MergeCommandResult mergeCommandResult = command.merge(request);
+
+    assertThat(mergeCommandResult.isSuccess()).isTrue();
+
+    Repository repository = createContext().open();
+    Iterable<RevCommit> commits = new Git(repository).log().add(repository.resolve("master")).setMaxCount(1).call();
+    RevCommit mergeCommit = commits.iterator().next();
+    String message = mergeCommit.getFullMessage();
+    assertThat(message).isEqualTo("simple");
+  }
+
+  @Test
+  public void shouldNotMergeConflictingBranches() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setBranchToMerge("test-branch");
+    request.setTargetBranch("master");
+
+    MergeCommandResult mergeCommandResult = command.merge(request);
+
+    assertThat(mergeCommandResult.isSuccess()).isFalse();
+    assertThat(mergeCommandResult.getFilesWithConflict()).containsExactly("a.txt");
+  }
+
+  @Test
+  @SubjectAware(username = "admin", password = "secret")
+  public void shouldTakeAuthorFromSubjectIfNotSet() throws IOException, GitAPIException {
+    shiro.setSubject(
+      new Subject.Builder()
+        .principals(new SimplePrincipalCollection(new User("dirk", "Dirk Gently", "dirk@holistic.det"), REALM))
+        .buildSubject());
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("master");
+    request.setBranchToMerge("mergeable");
+
+    MergeCommandResult mergeCommandResult = command.merge(request);
+
+    assertThat(mergeCommandResult.isSuccess()).isTrue();
+
+    Repository repository = createContext().open();
+    Iterable<RevCommit> mergeCommit = new Git(repository).log().add(repository.resolve("master")).setMaxCount(1).call();
+    PersonIdent mergeAuthor = mergeCommit.iterator().next().getAuthorIdent();
+    assertThat(mergeAuthor.getName()).isEqualTo("Dirk Gently");
+    assertThat(mergeAuthor.getEmailAddress()).isEqualTo("dirk@holistic.det");
+  }
+
+  private GitMergeCommand createCommand() {
+    return new GitMergeCommand(createContext(), repository, new SimpleGitWorkdirFactory());
+  }
+}

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/SimpleGitWorkdirFactoryTest.java

@@ -0,0 +1,87 @@
+package sonia.scm.repository.spi;
+
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+public class SimpleGitWorkdirFactoryTest extends AbstractGitCommandTestBase {
+
+  @Rule
+  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  @Test
+  public void emptyPoolShouldCreateNewWorkdir() throws IOException {
+    SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
+    File masterRepo = createRepositoryDirectory();
+
+    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+
+      assertThat(workingCopy.get().getDirectory())
+        .exists()
+        .isNotEqualTo(masterRepo)
+        .isDirectory();
+      assertThat(new File(workingCopy.get().getWorkTree(), "a.txt"))
+        .exists()
+        .isFile()
+        .hasContent("a\nline for blame");
+    }
+  }
+
+  @Test
+  public void cloneFromPoolShouldBeClosed() throws IOException {
+    PoolWithSpy factory = new PoolWithSpy(temporaryFolder.newFolder());
+
+    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+      assertThat(workingCopy).isNotNull();
+    }
+    verify(factory.createdClone).close();
+  }
+
+  @Test
+  public void cloneFromPoolShouldNotBeReused() throws IOException {
+    SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
+
+    File firstDirectory;
+    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+      firstDirectory = workingCopy.get().getDirectory();
+    }
+    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+      File secondDirectory = workingCopy.get().getDirectory();
+      assertThat(secondDirectory).isNotEqualTo(firstDirectory);
+    }
+  }
+
+  @Test
+  public void cloneFromPoolShouldBeDeletedOnClose() throws IOException {
+    SimpleGitWorkdirFactory factory = new SimpleGitWorkdirFactory(temporaryFolder.newFolder());
+
+    File directory;
+    try (WorkingCopy workingCopy = factory.createWorkingCopy(createContext())) {
+      directory = workingCopy.get().getWorkTree();
+    }
+    assertThat(directory).doesNotExist();
+  }
+
+  private static class PoolWithSpy extends SimpleGitWorkdirFactory {
+    PoolWithSpy(File poolDirectory) {
+      super(poolDirectory);
+    }
+
+    Repository createdClone;
+
+    @Override
+    protected Repository cloneRepository(File bareRepository, File destination) throws GitAPIException {
+      createdClone = spy(super.cloneRepository(bareRepository, destination));
+      return createdClone;
+    }
+  }
+}