Merge pull request #95 from DevFactory/df-docker-plugin-unit-tests

Unit tests to increase code coverage from 33% to 86%

Author: alexec

CODE_COVERAGE.md

@@ -0,0 +1,7 @@
+# Code Coverage Report generation
+
+To generate the code coverage report, execute the following command:
+> mvn clean verify
+
+This will generate code coverage report. In order to view it, open the following file in your browser
+> target/site/cobertura/index.html

pom.xml

@@ -147,6 +147,34 @@
 
     <build>
         <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>cobertura-maven-plugin</artifactId>
+                <version>2.7</version>
+                <configuration>
+                    <check>
+                        true
+                    </check>
+                    <formats>
+                        <format>html</format>
+                    </formats>
+                    <outputDirectory>${project.build.directory}/site/cobertura</outputDirectory>
+                    <instrumentation>
+                        <ignoreTrivial>true</ignoreTrivial>
+                        <excludes>
+                            <exclude>**/HelpMojo.class</exclude>
+                        </excludes>
+                    </instrumentation>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>cobertura</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
             <plugin>
                 <artifactId>maven-enforcer-plugin</artifactId>
                 <version>1.3.1</version>

src/main/java/com/alexecollins/docker/mojo/AbstractDockerMojo.java

@@ -5,7 +5,7 @@
 import com.alexecollins.docker.orchestration.model.BuildFlag;
 import com.alexecollins.docker.util.MavenLogAppender;
 import com.github.dockerjava.api.DockerClient;
-import com.github.dockerjava.api.exception.DockerException;
+import com.github.dockerjava.api.DockerException;
 import com.github.dockerjava.api.command.VersionCmd;
 import com.github.dockerjava.api.model.Version;
 import com.github.dockerjava.core.DockerClientBuilder;

src/test/java/com/alexecollins/docker/mojo/AbstractDockerMojoTest.java

@@ -1,16 +1,24 @@
 package com.alexecollins.docker.mojo;
 
 import com.alexecollins.docker.orchestration.DockerOrchestrator;
+import com.alexecollins.docker.orchestration.model.BuildFlag;
 import com.github.dockerjava.api.DockerClient;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.powermock.api.mockito.PowerMockito;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 import org.powermock.reflect.Whitebox;
 
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doThrow;
@@ -24,25 +32,75 @@ public class AbstractDockerMojoTest extends MojoTestSupport {
 
     private AbstractDockerMojo dockerMojo;
 
+    private DockerClient dockerClient;
+
     @Before
     public void setUp() throws Exception {
-        // prepare mojo
         dockerMojo = PowerMockito.spy(new AbstractDockerMojo() {
             @Override
             protected void doExecute(DockerOrchestrator orchestrator) throws Exception {
                 // do nothing
             }
         });
+        dockerClient = mock(DockerClient.class);
+
+        prepareMojo(dockerMojo, dockerClient, null);
+    }
+
+    @Test
+    public void testExecution() throws Exception {
+        // given
+        ArgumentCaptor<DockerOrchestrator> captor = ArgumentCaptor.forClass(DockerOrchestrator.class);
+
+        // when
+        dockerMojo.execute();
+
+        // then
+        verify(dockerMojo).doExecute(captor.capture());
+        DockerOrchestrator capturedOrchestrator = captor.getValue();
+        assertNotNull(capturedOrchestrator);
 
-        DockerClient mockDockerClient = mock(DockerClient.class);
-        DockerOrchestrator mockDockerOrchestrator = mock(DockerOrchestrator.class);
+        assertEquals(dockerClient, Whitebox.getInternalState(capturedOrchestrator, "docker"));
 
-        prepareMojo(dockerMojo, mockDockerClient, mockDockerOrchestrator);
+        Set<BuildFlag> buildFlags = Whitebox.getInternalState(capturedOrchestrator, "buildFlags");
+        assertNotNull(buildFlags);
+        assertFalse(buildFlags.contains(BuildFlag.REMOVE_INTERMEDIATE_IMAGES));
+        assertFalse(buildFlags.contains(BuildFlag.NO_CACHE));
+        assertFalse(buildFlags.contains(BuildFlag.PULL));
+        assertFalse(buildFlags.contains(BuildFlag.QUIET));
     }
 
+    @Test
+    public void testExecutionWithFlags() throws Exception {
+        // given
+        Whitebox.setInternalState(dockerMojo, "removeIntermediateImages", true);
+        Whitebox.setInternalState(dockerMojo, "cache", false);
+        Whitebox.setInternalState(dockerMojo, "quiet", true);
+        Whitebox.setInternalState(dockerMojo, "pull", true);
+
+
+        ArgumentCaptor<DockerOrchestrator> captor = ArgumentCaptor.forClass(DockerOrchestrator.class);
 
+        // when
+        dockerMojo.execute();
+        
+        // then
+        verify(dockerMojo).doExecute(captor.capture());
+        DockerOrchestrator capturedOrchestrator = captor.getValue();
+        assertNotNull(capturedOrchestrator);
+
+        assertEquals(dockerClient, Whitebox.getInternalState(capturedOrchestrator, "docker"));
+
+        Set<BuildFlag> buildFlags = Whitebox.getInternalState(capturedOrchestrator, "buildFlags");
+        assertNotNull(buildFlags);
+        assertTrue(buildFlags.contains(BuildFlag.REMOVE_INTERMEDIATE_IMAGES));
+        assertTrue(buildFlags.contains(BuildFlag.NO_CACHE));
+        assertTrue(buildFlags.contains(BuildFlag.PULL));
+        assertTrue(buildFlags.contains(BuildFlag.QUIET));
+    }
+    
     @Test
-    public void testSkip() throws Exception {
+    public void testExecutionWithSkip() throws Exception {
         // given
         Whitebox.setInternalState(dockerMojo, "skip", true);
 

src/test/java/com/alexecollins/docker/mojo/CopyMojoTest.java

@@ -0,0 +1,57 @@
+package com.alexecollins.docker.mojo;
+
+import com.alexecollins.docker.orchestration.DockerOrchestrator;
+import com.github.dockerjava.api.DockerClient;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(CopyMojo.class)
+public class CopyMojoTest extends MojoTestSupport {
+
+    private static final String SOURCE = "source";
+
+    private static final String DEST = "dest";
+
+    private CopyMojo copyMojo;
+
+    private DockerOrchestrator mockDockerOrchestrator;
+
+    @Before
+    public void setUp() throws Exception {
+
+        copyMojo = PowerMockito.spy(new CopyMojo());
+        DockerClient mockDockerClient = mock(DockerClient.class);
+        mockDockerOrchestrator = mock(DockerOrchestrator.class);
+
+        prepareMojo(copyMojo, mockDockerClient, mockDockerOrchestrator);
+        Whitebox.setInternalState(copyMojo, "resource", SOURCE);
+        Whitebox.setInternalState(copyMojo, "dest", DEST);
+    }
+
+    @Test
+    public void testCopy() throws Exception {
+        // when
+        copyMojo.execute();
+
+        // then
+        verify(copyMojo).doExecute(mockDockerOrchestrator);
+        verify(mockDockerOrchestrator).copy(SOURCE, DEST);
+    }
+
+    @Test
+    public void testGetters() {
+        assertEquals(SOURCE, copyMojo.getSource());
+        assertEquals(DEST, copyMojo.getDest());
+    }
+}
+

src/test/java/com/alexecollins/docker/mojo/DeployMojoTest.java

@@ -0,0 +1,42 @@
+package com.alexecollins.docker.mojo;
+
+import com.alexecollins.docker.orchestration.DockerOrchestrator;
+import com.github.dockerjava.api.DockerClient;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(DeployMojo.class)
+public class DeployMojoTest extends MojoTestSupport {
+
+    private DeployMojo deployMojo;
+
+    private DockerOrchestrator mockDockerOrchestrator;
+
+    @Before
+    public void setUp() throws Exception {
+
+        deployMojo = PowerMockito.spy(new DeployMojo());
+        DockerClient mockDockerClient = mock(DockerClient.class);
+        mockDockerOrchestrator = mock(DockerOrchestrator.class);
+
+        prepareMojo(deployMojo, mockDockerClient, mockDockerOrchestrator);
+    }
+
+    @Test
+    public void testDeploy() throws Exception {
+        // when
+        deployMojo.execute();
+
+        // then
+        verify(deployMojo).doExecute(mockDockerOrchestrator);
+        verify(mockDockerOrchestrator).push();
+    }
+}

src/test/java/com/alexecollins/docker/mojo/MojoTestSupport.java

@@ -4,17 +4,23 @@
 import com.github.dockerjava.api.DockerClient;
 import com.github.dockerjava.api.command.VersionCmd;
 import com.github.dockerjava.api.model.Version;
+import com.github.dockerjava.core.DockerClientBuilder;
+import com.github.dockerjava.core.DockerClientConfig;
 import org.apache.maven.model.Build;
 import org.apache.maven.project.MavenProject;
-import org.mockito.Mockito;
 import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.reflect.Whitebox;
 
+import java.io.File;
 import java.util.Properties;
 
+import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
 
+@PrepareForTest(DockerClientBuilder.class)
 public class MojoTestSupport {
 
     protected static final String PROJECT_GROUP_ID = "id.group";
@@ -27,10 +33,18 @@ public class MojoTestSupport {
 
     protected static final String PROJECT_DESCRIPTION = "Project Description";
 
-    protected static final String BUILD_DIRECTORY = "/build/directory";
+    protected static final String BUILD_DIR = "/build/dir";
 
     protected static final String BUILD_FINAL_NAME = "buildFinalName";
 
+    protected static final String BASE_DIR = "src";
+
+    protected static final String SRC = "main";
+
+    protected static final String PREFIX = "prefix";
+
+    protected static final String USERNAME = "username";
+
 
     protected void prepareMojo(
             AbstractDockerMojo dockerMojo,
@@ -39,13 +53,20 @@ protected void prepareMojo(
 
         MavenProject mavenProject = createMavenProject();
         Whitebox.setInternalState(dockerMojo, "project", mavenProject);
+        Whitebox.setInternalState(dockerMojo, "prefix", PREFIX);
+        Whitebox.setInternalState(dockerMojo, "src", SRC);
+        Whitebox.setInternalState(dockerMojo, "username", USERNAME);
 
         // prepare docker client
         if (mockDockerClient != null) {
             VersionCmd mockVersionCmd = mock(VersionCmd.class);
             Version mockVersion = mock(Version.class);
 
-            PowerMockito.doReturn(mockDockerClient).when(dockerMojo, "dockerClient");
+            DockerClientBuilder mockDockerClientBuilder = mock(DockerClientBuilder.class);
+            when(mockDockerClientBuilder.build()).thenReturn(mockDockerClient);
+
+            mockStatic(DockerClientBuilder.class);
+            when(DockerClientBuilder.getInstance(any(DockerClientConfig.class))).thenReturn(mockDockerClientBuilder);
 
             when(mockDockerClient.versionCmd()).thenReturn(mockVersionCmd);
             when(mockVersionCmd.exec()).thenReturn(mockVersion);
@@ -56,8 +77,8 @@ protected void prepareMojo(
         if (mockDockerOrchestrator != null) {
             PowerMockito.doReturn(mockDockerOrchestrator)
                     .when(dockerMojo, "dockerOrchestrator",
-                            Mockito.any(Properties.class),
-                            Mockito.any(DockerClient.class)
+                            any(Properties.class),
+                            any(DockerClient.class)
                     );
         }
     }
@@ -72,17 +93,18 @@ protected MavenProject createMavenProject() {
         mavenProject.setDescription(PROJECT_DESCRIPTION);
         mavenProject.setBuild(createBuild());
 
+        mavenProject.setFile(new File(new File(BASE_DIR), "file"));
+
         return mavenProject;
     }
 
     protected Build createBuild() {
 
         Build build = new Build();
 
-        build.setDirectory(BUILD_DIRECTORY);
+        build.setDirectory(BUILD_DIR);
         build.setFinalName(BUILD_FINAL_NAME);
 
         return build;
     }
-
 }