Merge with 2.0.0-m3

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

@@ -49,6 +49,7 @@ import org.eclipse.jgit.treewalk.filter.PathFilter;
 import org.eclipse.jgit.treewalk.filter.TreeFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import sonia.scm.NotFoundException;
 import sonia.scm.repository.Changeset;
 import sonia.scm.repository.ChangesetPagingResult;
 import sonia.scm.repository.GitChangesetConverter;
@@ -206,6 +207,9 @@ public class GitLogCommand extends AbstractGitCommand implements LogCommand
 
         if (!Strings.isNullOrEmpty(request.getAncestorChangeset())) {
           ancestorId = repository.resolve(request.getAncestorChangeset());
+          if (ancestorId == null) {
+            throw notFound(entity("Revision", request.getAncestorChangeset()).in(this.repository));
+          }
         }
 
         revWalk = new RevWalk(repository);
@@ -245,6 +249,8 @@ public class GitLogCommand extends AbstractGitCommand implements LogCommand
               break;
             }
           }
+        } else if (ancestorId != null) {
+          throw notFound(entity("Revision", request.getBranch()).in(this.repository));
         }
 
         if (branch != null) {
@@ -263,6 +269,10 @@ public class GitLogCommand extends AbstractGitCommand implements LogCommand
     {
       throw notFound(entity("Revision", e.getObjectId().getName()).in(repository));
     }
+    catch (NotFoundException e)
+    {
+      throw e;
+    }
     catch (Exception ex)
     {
       throw new InternalRepositoryException(repository, "could not create change log", ex);

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

@@ -62,12 +62,24 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
     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())));
+      return new MergeDryRunCommandResult(
+        merger.merge(
+          resolveRevisionOrThrowNotFound(repository, request.getBranchToMerge()),
+          resolveRevisionOrThrowNotFound(repository, request.getTargetBranch())));
     } catch (IOException e) {
       throw new InternalRepositoryException(context.getRepository(), "could not clone repository for merge", e);
     }
   }
 
+  private ObjectId resolveRevisionOrThrowNotFound(Repository repository, String revision) throws IOException {
+    ObjectId resolved = repository.resolve(revision);
+    if (resolved == null) {
+      throw notFound(entity("revision", revision).in(context.getRepository()));
+    } else {
+      return resolved;
+    }
+  }
+
   private class MergeWorker {
 
     private final String target;
@@ -110,9 +122,6 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
     private void checkOutTargetAsNewLocalBranch() throws IOException {
       try {
         ObjectId targetRevision = resolveRevision(target);
-        if (targetRevision == null) {
-          throw notFound(entity("revision", target).in(context.getRepository()));
-        }
         clone.checkout().setStartPoint(targetRevision.getName()).setName(target).setCreateBranch(true).call();
       } catch (RefNotFoundException e) {
         logger.debug("could not checkout target branch {} for merge as local branch", target, e);
@@ -126,9 +135,6 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
       MergeResult result;
       try {
         ObjectId sourceRevision = resolveRevision(toMerge);
-        if (sourceRevision == null) {
-          throw notFound(entity("revision", toMerge).in(context.getRepository()));
-        }
         result = clone.merge()
           .setFastForward(FastForwardMode.NO_FF)
           .setCommit(false) // we want to set the author manually
@@ -190,10 +196,10 @@ public class GitMergeCommand extends AbstractGitCommand implements MergeCommand
       return MergeCommandResult.failure(result.getConflicts().keySet());
     }
 
-    private ObjectId resolveRevision(String branchToMerge) throws IOException {
-      ObjectId resolved = clone.getRepository().resolve(branchToMerge);
+    private ObjectId resolveRevision(String revision) throws IOException {
+      ObjectId resolved = clone.getRepository().resolve(revision);
       if (resolved == null) {
-        return clone.getRepository().resolve("origin/" + branchToMerge);
+        return resolveRevisionOrThrowNotFound(clone.getRepository(), "origin/" + revision);
       } else {
         return resolved;
       }

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

@@ -35,6 +35,7 @@
 package sonia.scm.repository.spi;
 
 import org.junit.Test;
+import sonia.scm.NotFoundException;
 import sonia.scm.repository.ChangesetPagingResult;
 
 import static org.junit.Assert.assertEquals;
@@ -95,6 +96,28 @@ public class GitLogCommandAncestorTest extends AbstractGitCommandTestBase
     assertEquals("201ecc1131e6b99fb0a0fe9dcbc8c044383e1a07", result.getChangesets().get(6).getId());
   }
 
+  @Test(expected = NotFoundException.class)
+  public void testAncestorWithDeletedSourceBranch()
+  {
+    LogCommandRequest request = new LogCommandRequest();
+
+    request.setBranch("no_such_branch");
+    request.setAncestorChangeset("master");
+
+    createCommand().getChangesets(request);
+  }
+
+  @Test(expected = NotFoundException.class)
+  public void testAncestorWithDeletedAncestorBranch()
+  {
+    LogCommandRequest request = new LogCommandRequest();
+
+    request.setBranch("b");
+    request.setAncestorChangeset("no_such_branch");
+
+    createCommand().getChangesets(request);
+  }
+
   private GitLogCommand createCommand()
   {
     return new GitLogCommand(createContext(), repository);

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

@@ -16,12 +16,14 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
+import sonia.scm.NotFoundException;
 import sonia.scm.repository.GitRepositoryHandler;
 import sonia.scm.repository.Person;
 import sonia.scm.repository.PreProcessorUtil;
 import sonia.scm.repository.RepositoryManager;
 import sonia.scm.repository.api.HookContextFactory;
 import sonia.scm.repository.api.MergeCommandResult;
+import sonia.scm.repository.api.MergeDryRunCommandResult;
 import sonia.scm.user.User;
 
 import java.io.IOException;
@@ -220,6 +222,46 @@ public class GitMergeCommandTest extends AbstractGitCommandTestBase {
     assertThat(new String(contentOfFileB)).isEqualTo("b\ncontent from branch\n");
   }
 
+  @Test(expected = NotFoundException.class)
+  public void shouldHandleNotExistingSourceBranchInMerge() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("mergeable");
+    request.setBranchToMerge("not_existing");
+
+    command.merge(request);
+  }
+
+  @Test(expected = NotFoundException.class)
+  public void shouldHandleNotExistingTargetBranchInMerge() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("not_existing");
+    request.setBranchToMerge("master");
+
+    command.merge(request);
+  }
+
+  @Test(expected = NotFoundException.class)
+  public void shouldHandleNotExistingSourceBranchInDryRun() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("mergeable");
+    request.setBranchToMerge("not_existing");
+
+    command.dryRun(request);
+  }
+
+  @Test(expected = NotFoundException.class)
+  public void shouldHandleNotExistingTargetBranchInDryRun() {
+    GitMergeCommand command = createCommand();
+    MergeCommandRequest request = new MergeCommandRequest();
+    request.setTargetBranch("not_existing");
+    request.setBranchToMerge("master");
+
+    command.dryRun(request);
+  }
+
   private GitMergeCommand createCommand() {
     return new GitMergeCommand(createContext(), repository, new SimpleGitWorkdirFactory());
   }