Add some unit tests.

Had to introduce mockito as a (test) dependency.

Refactored GitService a little to allow for mocks.

Author: Charles Overbeck

pom.xml

@@ -103,6 +103,12 @@
             <artifactId>org.eclipse.jgit</artifactId>
             <version>4.8.0.201706111038-r</version>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>1.10.19</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/org/commonwl/view/git/GitService.java

@@ -33,6 +33,7 @@
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
+import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -85,22 +86,12 @@ public Git getRepository(GitDetails gitDetails, boolean reuseDir)
             } else {
                 // Create a folder and clone repository into it
                 Files.createDirectory(repoDir);
-                repo = Git.cloneRepository()
-                        .setCloneSubmodules(cloneSubmodules)
-                        .setURI(gitDetails.getRepoUrl())
-                        .setDirectory(repoDir.toFile())
-                        .setCloneAllBranches(true)
-                        .call();
+                repo = cloneRepo(gitDetails.getRepoUrl(), repoDir.toFile());
             }
         } else {
             // Another thread is already using the existing folder
             // Must create another temporary one
-            repo = Git.cloneRepository()
-                    .setCloneSubmodules(cloneSubmodules)
-                    .setURI(gitDetails.getRepoUrl())
-                    .setDirectory(createTempDir())
-                    .setCloneAllBranches(true)
-                    .call();
+            repo = cloneRepo(gitDetails.getRepoUrl(), createTempDir());
         }
 
         // Checkout the specific branch or commit ID
@@ -206,4 +197,19 @@ public GitDetails transferPathToBranch(GitDetails githubInfo) {
         }
     }
 
+    /**
+     * Clones a Git repository
+     * @param repoUrl the url of the Git repository
+     * @param directory the directory to clone the repo into
+     * @return a Git instance
+     * @throws GitAPIException if any error occurs cloning the repo
+     */
+    protected Git cloneRepo(String repoUrl, File directory) throws GitAPIException {
+        return Git.cloneRepository()
+                .setCloneSubmodules(cloneSubmodules)
+                .setURI(repoUrl)
+                .setDirectory(directory)
+                .setCloneAllBranches(true)
+                .call();
+    }
 }

src/test/java/org/commonwl/view/git/GitServiceTest.java

@@ -19,12 +19,51 @@
 
 package org.commonwl.view.git;
 
+import java.io.File;
+import java.io.IOException;
+
+import org.eclipse.jgit.api.CheckoutCommand;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.RefNotFoundException;
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
 
 public class GitServiceTest {
 
+    private final RefNotFoundException branchNotFoundException = new RefNotFoundException("Branch not found");
+    private final RefNotFoundException tagNotFoundException = new RefNotFoundException("Tag not found");
+
+    private GitService spyGitService;
+    private Git mockGit;
+    private CheckoutCommand mockGoodCheckoutCommand;
+    private CheckoutCommand mockBranchNotFoundCommand;
+    private CheckoutCommand mockTagNotFoundCommand;
+    private CheckoutCommand mockCheckoutCommand;
+
+    @Before
+    public void setup() throws GitAPIException {
+        GitService gitService = new GitService(null, false);
+        this.spyGitService = spy(gitService);
+        this.mockGit = mock(Git.class);
+        this.mockGoodCheckoutCommand = mock(CheckoutCommand.class);
+        this.mockBranchNotFoundCommand = mock(CheckoutCommand.class);
+        this.mockTagNotFoundCommand = mock(CheckoutCommand.class);
+        this.mockCheckoutCommand = mock(CheckoutCommand.class);
+        when(this.mockGit.checkout()).thenReturn(this.mockCheckoutCommand);
+        when(this.mockBranchNotFoundCommand.call()).thenThrow(branchNotFoundException);
+        when(this.mockTagNotFoundCommand.call()).thenThrow(tagNotFoundException);
+    }
+
     @Test
     public void transferPathToBranch() throws Exception {
         GitService gitService = new GitService(null, false);
@@ -39,4 +78,35 @@ public void transferPathToBranch() throws Exception {
         assertEquals("branchpart1/branchpart2/branchpart3", step2.getBranch());
         assertEquals("workflowInRoot.cwl", step2.getPath());
     }
+
+    @Test
+    public void checksOutTag() throws Exception {
+        when(mockCheckoutCommand.setName("refs/remotes/origin/mytag")).thenReturn(this.mockBranchNotFoundCommand);
+        when(mockCheckoutCommand.setName("mytag")).thenReturn(this.mockGoodCheckoutCommand);
+        doReturn(this.mockGit).when(this.spyGitService).cloneRepo(Mockito.any(String.class), Mockito.any(File.class));
+        assertNotNull(this.spyGitService.getRepository(new GitDetails(null, "mytag", "foo"), false));
+    }
+
+    @Test
+    public void checksOutBranch() throws GitAPIException, IOException {
+        when(mockCheckoutCommand.setName("refs/remotes/origin/mybranch")).thenReturn(this.mockGoodCheckoutCommand);
+        when(mockCheckoutCommand.setName("mytag")).thenReturn(this.mockTagNotFoundCommand);
+        doReturn(this.mockGit).when(this.spyGitService).cloneRepo(Mockito.any(String.class), Mockito.any(File.class));
+        assertNotNull(this.spyGitService.getRepository(new GitDetails(null, "mybranch", "foo"), false));
+    }
+
+    @Test()
+    public void throwsFirstExceptionIfTagAndBranchFail() throws GitAPIException {
+        when(mockCheckoutCommand.setName("refs/remotes/origin/mytag")).thenReturn(this.mockBranchNotFoundCommand);
+        when(mockCheckoutCommand.setName("mytag")).thenReturn(this.mockTagNotFoundCommand);
+        doReturn(this.mockGit).when(this.spyGitService).cloneRepo(Mockito.any(String.class), Mockito.any(File.class));
+        boolean thrown = false;
+        try {
+            this.spyGitService.getRepository(new GitDetails(null, "mytag", "foo"), false);
+        } catch (Exception e) {
+            // Make sure it's not this.tagNotFoundException
+            thrown = (e == this.branchNotFoundException);
+        }
+        assertTrue(thrown);
+    }
 }