Merged in feature/merge_api (pull request #106)

Feature merge api

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/CloseableWrapper.java

@@ -0,0 +1,25 @@
+package sonia.scm.repository;
+
+import java.util.function.Consumer;
+
+public class CloseableWrapper<C> implements AutoCloseable {
+
+  private final C wrapped;
+  private final Consumer<C> cleanup;
+
+  public CloseableWrapper(C wrapped, Consumer<C> cleanup) {
+    this.wrapped = wrapped;
+    this.cleanup = cleanup;
+  }
+
+  public C get() { return wrapped; }
+
+  @Override
+  public void close() {
+    try {
+      cleanup.accept(wrapped);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/GitRepositoryHandler.java

@@ -90,6 +90,8 @@ public class GitRepositoryHandler
   private static final Object LOCK = new Object();
   
   private final Scheduler scheduler;
+
+  private final GitWorkdirFactory workdirFactory;
   
   private Task task;
   
@@ -104,10 +106,11 @@ public class GitRepositoryHandler
    * @param scheduler
    */
   @Inject
-  public GitRepositoryHandler(ConfigurationStoreFactory storeFactory, FileSystem fileSystem, Scheduler scheduler)
+  public GitRepositoryHandler(ConfigurationStoreFactory storeFactory, FileSystem fileSystem, Scheduler scheduler, GitWorkdirFactory workdirFactory)
   {
     super(storeFactory, fileSystem);
     this.scheduler = scheduler;
+    this.workdirFactory = workdirFactory;
   }
 
   //~--- get methods ----------------------------------------------------------
@@ -234,4 +237,8 @@ public class GitRepositoryHandler
   {
     return new File(directory, DIRECTORY_REFS).exists();
   }
+
+  public GitWorkdirFactory getWorkdirFactory() {
+    return workdirFactory;
+  }
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/GitWorkdirFactory.java

@@ -0,0 +1,8 @@
+package sonia.scm.repository;
+
+import sonia.scm.repository.spi.GitContext;
+import sonia.scm.repository.spi.WorkingCopy;
+
+public interface GitWorkdirFactory {
+  WorkingCopy createWorkingCopy(GitContext gitContext);
+}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitContext.java

@@ -106,6 +106,10 @@ public class GitContext implements Closeable
     return repository;
   }
 
+  File getDirectory() {
+    return directory;
+  }
+
   //~--- fields ---------------------------------------------------------------
 
   /** Field description */

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitMergeCommand.java

@@ -0,0 +1,169 @@
+package sonia.scm.repository.spi;
+
+import com.google.common.base.Strings;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.subject.Subject;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.MergeResult;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.merge.MergeStrategy;
+import org.eclipse.jgit.merge.ResolveMerger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sonia.scm.repository.GitWorkdirFactory;
+import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.Person;
+import sonia.scm.repository.api.MergeCommandResult;
+import sonia.scm.repository.api.MergeDryRunCommandResult;
+import sonia.scm.user.User;
+
+import java.io.IOException;
+import java.text.MessageFormat;
+
+public class GitMergeCommand extends AbstractGitCommand implements MergeCommand {
+
+  private static final Logger logger = LoggerFactory.getLogger(GitMergeCommand.class);
+
+  private static final String MERGE_COMMIT_MESSAGE_TEMPLATE = String.join("\n",
+    "Merge of branch {0} into {1}",
+    "",
+    "Automatic merge by SCM-Manager.");
+
+  private final GitWorkdirFactory workdirFactory;
+
+  GitMergeCommand(GitContext context, sonia.scm.repository.Repository repository, GitWorkdirFactory workdirFactory) {
+    super(context, repository);
+    this.workdirFactory = workdirFactory;
+  }
+
+  @Override
+  public MergeCommandResult merge(MergeCommandRequest request) {
+    try (WorkingCopy workingCopy = workdirFactory.createWorkingCopy(context)) {
+      Repository repository = workingCopy.get();
+      logger.debug("cloned repository to folder {}", repository.getWorkTree());
+      return new MergeWorker(repository, request).merge();
+    } catch (IOException e) {
+      throw new InternalRepositoryException("could not clone repository for merge", e);
+    }
+  }
+
+  @Override
+  public MergeDryRunCommandResult dryRun(MergeCommandRequest request) {
+    try {
+      Repository repository = context.open();
+      ResolveMerger merger = (ResolveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);
+      return new MergeDryRunCommandResult(merger.merge(repository.resolve(request.getBranchToMerge()), repository.resolve(request.getTargetBranch())));
+    } catch (IOException e) {
+      throw new InternalRepositoryException("could not clone repository for merge", e);
+    }
+  }
+
+  private static class MergeWorker {
+
+    private final String target;
+    private final String toMerge;
+    private final Person author;
+    private final Git clone;
+    private final String messageTemplate;
+
+    private MergeWorker(Repository clone, MergeCommandRequest request) {
+      this.target = request.getTargetBranch();
+      this.toMerge = request.getBranchToMerge();
+      this.author = request.getAuthor();
+      this.messageTemplate = request.getMessageTemplate();
+      this.clone = new Git(clone);
+    }
+
+    private MergeCommandResult merge() throws IOException {
+      checkOutTargetBranch();
+      MergeResult result = doMergeInClone();
+      if (result.getMergeStatus().isSuccessful()) {
+        doCommit();
+        push();
+        return MergeCommandResult.success();
+      } else {
+        return analyseFailure(result);
+      }
+    }
+
+    private void checkOutTargetBranch() {
+      try {
+        clone.checkout().setName(target).call();
+      } catch (GitAPIException e) {
+        throw new InternalRepositoryException("could not checkout target branch for merge: " + target, e);
+      }
+    }
+
+    private MergeResult doMergeInClone() throws IOException {
+      MergeResult result;
+      try {
+        result = clone.merge()
+          .setCommit(false) // we want to set the author manually
+          .include(toMerge, resolveRevision(toMerge))
+          .call();
+      } catch (GitAPIException e) {
+        throw new InternalRepositoryException("could not merge branch " + toMerge + " into " + target, e);
+      }
+      return result;
+    }
+
+    private void doCommit() {
+      logger.debug("merged branch {} into {}", toMerge, target);
+      Person authorToUse = determineAuthor();
+      try {
+        clone.commit()
+          .setAuthor(authorToUse.getName(), authorToUse.getMail())
+          .setMessage(MessageFormat.format(determineMessageTemplate(), toMerge, target))
+          .call();
+      } catch (GitAPIException e) {
+        throw new InternalRepositoryException("could not commit merge between branch " + toMerge + " and " + target, e);
+      }
+    }
+
+    private String determineMessageTemplate() {
+      if (Strings.isNullOrEmpty(messageTemplate)) {
+        return MERGE_COMMIT_MESSAGE_TEMPLATE;
+      } else {
+        return messageTemplate;
+      }
+    }
+
+    private Person determineAuthor() {
+      if (author == null) {
+        Subject subject = SecurityUtils.getSubject();
+        User user = subject.getPrincipals().oneByType(User.class);
+        String name = user.getDisplayName();
+        String email = user.getMail();
+        logger.debug("no author set; using logged in user: {} <{}>", name, email);
+        return new Person(name, email);
+      } else {
+        return author;
+      }
+    }
+
+    private void push() {
+      try {
+        clone.push().call();
+      } catch (GitAPIException e) {
+        throw new InternalRepositoryException("could not push merged branch " + toMerge + " to origin", e);
+      }
+      logger.debug("pushed merged branch {}", target);
+    }
+
+    private MergeCommandResult analyseFailure(MergeResult result) {
+      logger.info("could not merged branch {} into {} due to conflict in paths {}", toMerge, target, result.getConflicts().keySet());
+      return MergeCommandResult.failure(result.getConflicts().keySet());
+    }
+
+    private ObjectId resolveRevision(String branchToMerge) throws IOException {
+      ObjectId resolved = clone.getRepository().resolve(branchToMerge);
+      if (resolved == null) {
+        return clone.getRepository().resolve("origin/" + branchToMerge);
+      } else {
+        return resolved;
+      }
+    }
+  }
+}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitRepositoryServiceProvider.java

@@ -63,7 +63,8 @@ public class GitRepositoryServiceProvider extends RepositoryServiceProvider
     Command.INCOMING,
     Command.OUTGOING,
     Command.PUSH,
-    Command.PULL
+    Command.PULL,
+    Command.MERGE
   );
   //J+
 
@@ -240,7 +241,12 @@ public class GitRepositoryServiceProvider extends RepositoryServiceProvider
     return new GitTagsCommand(context, repository);
   }
 
-  //~--- fields ---------------------------------------------------------------
+  @Override
+  public MergeCommand getMergeCommand() {
+    return new GitMergeCommand(context, repository, handler.getWorkdirFactory());
+  }
+
+//~--- fields ---------------------------------------------------------------
 
   /** Field description */
   private GitContext context;

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/SimpleGitWorkdirFactory.java

@@ -0,0 +1,62 @@
+package sonia.scm.repository.spi;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.util.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sonia.scm.repository.GitWorkdirFactory;
+import sonia.scm.repository.InternalRepositoryException;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
+public class SimpleGitWorkdirFactory implements GitWorkdirFactory {
+
+  private static final Logger logger = LoggerFactory.getLogger(SimpleGitWorkdirFactory.class);
+
+  private final File poolDirectory;
+
+  public SimpleGitWorkdirFactory() {
+    this(new File(System.getProperty("java.io.tmpdir"), "scmm-git-pool"));
+  }
+
+  public SimpleGitWorkdirFactory(File poolDirectory) {
+    this.poolDirectory = poolDirectory;
+    poolDirectory.mkdirs();
+  }
+
+  public WorkingCopy createWorkingCopy(GitContext gitContext) {
+    try {
+      Repository clone = cloneRepository(gitContext.getDirectory(), createNewWorkdir());
+      return new WorkingCopy(clone, this::close);
+    } catch (GitAPIException e) {
+      throw new InternalRepositoryException("could not clone working copy of repository", e);
+    } catch (IOException e) {
+      throw new InternalRepositoryException("could not create temporary directory for clone of repository", e);
+    }
+  }
+
+  private File createNewWorkdir() throws IOException {
+    return Files.createTempDirectory(poolDirectory.toPath(),"workdir").toFile();
+  }
+
+  protected Repository cloneRepository(File bareRepository, File target) throws GitAPIException {
+    return Git.cloneRepository()
+      .setURI(bareRepository.getAbsolutePath())
+      .setDirectory(target)
+      .call()
+      .getRepository();
+  }
+
+  private void close(Repository repository) {
+    repository.close();
+    try {
+      FileUtils.delete(repository.getWorkTree(), FileUtils.RECURSIVE);
+    } catch (IOException e) {
+      logger.warn("could not delete temporary git workdir '{}'", repository.getWorkTree(), e);
+    }
+  }
+}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/WorkingCopy.java

@@ -0,0 +1,12 @@
+package sonia.scm.repository.spi;
+
+import org.eclipse.jgit.lib.Repository;
+import sonia.scm.repository.CloseableWrapper;
+
+import java.util.function.Consumer;
+
+public class WorkingCopy extends CloseableWrapper<Repository> {
+  WorkingCopy(Repository wrapped, Consumer<Repository> cleanup) {
+    super(wrapped, cleanup);
+  }
+}

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/web/GitServletModule.java

@@ -41,6 +41,8 @@ import org.mapstruct.factory.Mappers;
 import sonia.scm.api.v2.resources.GitConfigDtoToGitConfigMapper;
 import sonia.scm.api.v2.resources.GitConfigToGitConfigDtoMapper;
 import sonia.scm.plugin.Extension;
+import sonia.scm.repository.GitWorkdirFactory;
+import sonia.scm.repository.spi.SimpleGitWorkdirFactory;
 import sonia.scm.web.lfs.LfsBlobStoreFactory;
 
 /**
@@ -63,5 +65,7 @@ public class GitServletModule extends ServletModule
 
     bind(GitConfigDtoToGitConfigMapper.class).to(Mappers.getMapper(GitConfigDtoToGitConfigMapper.class).getClass());
     bind(GitConfigToGitConfigDtoMapper.class).to(Mappers.getMapper(GitConfigToGitConfigDtoMapper.class).getClass());
+
+    bind(GitWorkdirFactory.class).to(SimpleGitWorkdirFactory.class);
   }
 }

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;
+    }
+  }
+}