facillang · donghanglin · Jan 10, 2016
diff --git a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java
@@ -1,7 +1,16 @@
 package org.facil.practice;
 
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import com.amazonaws.services.lambda.AWSLambda;
 import org.junit.Test;
 
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+
 /**
  * User: blangel
  * Date: 12/31/15
@@ -10,8 +19,35 @@
 public class AbstractLambdaFileHandlerTest {
 
     @Test
-    public void createFileIfNotExists() {
-        // TODO
+    public void createFileIfNotExists() throws IOException {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        PrintStream printStream = new PrintStream(outputStream);
+        System.setOut(printStream);
+
+        String functionName = "Lambda";
+        String fileName = "aFile";
+        File file = mock(File.class);
+        AWSLambda awsLambda = mock(AWSLambda.class);
+        AbstractLambdaFileHandler abstractLambdaFileHandler
+            = spy(new AbstractLambdaFileHandler(functionName, fileName, file, awsLambda) {});
+
+        when(file.exists()).thenReturn(true).thenReturn(false);
+        when(file.createNewFile()).thenReturn(true).thenReturn(false).thenThrow(new IOException());
+
+        assertTrue(abstractLambdaFileHandler.createFileIfNotExists());
+        assertTrue(abstractLambdaFileHandler.createFileIfNotExists());
+        assertFalse(abstractLambdaFileHandler.createFileIfNotExists());
+        String errInfo = String.format("^error^ Could not create file [ %s ]^r^%n", fileName);
+        assertEquals(errInfo, outputStream.toString());
+        outputStream.reset();
+        assertFalse(abstractLambdaFileHandler.createFileIfNotExists());
+        assertEquals(errInfo, outputStream.toString());
+
+        verify(abstractLambdaFileHandler, times(4)).createFileIfNotExists();
+        verify(file, times(4)).exists();
+        verify(file, times(3)).createNewFile();
+
+        System.setOut(System.out);
     }
 
 }
diff --git a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java
@@ -1,7 +1,21 @@
 package org.facil.practice;
 
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.services.lambda.AWSLambda;
+import com.amazonaws.services.lambda.model.GetAliasRequest;
+import com.amazonaws.services.lambda.model.GetAliasResult;
+import com.amazonaws.services.lambda.model.GetFunctionRequest;
+import com.amazonaws.services.lambda.model.GetFunctionResult;
 import org.junit.Test;
 
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+
 /**
  * User: blangel
  * Date: 12/31/15
@@ -11,22 +25,79 @@ public class AbstractLambdaHandlerTest {
 
     @Test
     public void doesLambdaFunctionExist() {
-        // TODO
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaFileHandler.class);
+        when(abstractLambdaHandler.doesLambdaFunctionExist()).thenCallRealMethod();
+        when(abstractLambdaHandler.doesLambdaFunctionExist(true)).thenReturn(true);
+        assertTrue(abstractLambdaHandler.doesLambdaFunctionExist());
+        verify(abstractLambdaHandler).doesLambdaFunctionExist(true);
+        verify(abstractLambdaHandler).doesLambdaFunctionExist();
     }
 
     @Test
     public void doesLambdaFunctionExistWithArgument() {
-        // TODO
+        OutputStream os = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(os);
+        System.setOut(ps);
+
+        String functionName = "Lambda";
+        AWSLambda awsLambda = mock(AWSLambda.class);
+        GetFunctionResult getFunctionResult = mock(GetFunctionResult.class);
+        AbstractLambdaHandler abstractLambdaHandler = spy(new AbstractLambdaHandler(functionName, awsLambda) {});
+
+        when(awsLambda.getFunction(any(GetFunctionRequest.class)))
+                .thenThrow(new AmazonClientException("Amazon client Exception"))
+                .thenReturn(getFunctionResult);
+
+        assertFalse(abstractLambdaHandler.doesLambdaFunctionExist(true));
+        String errInfo = String.format("^error^ Lambda function [ %s ] does not exist^r^%n", functionName);
+        assertEquals(errInfo, os.toString());
+        assertTrue(abstractLambdaHandler.doesLambdaFunctionExist(true));
+
+        verify(abstractLambdaHandler, times(2)).doesLambdaFunctionExist(true);
+        verify(awsLambda, times(2)).getFunction(any(GetFunctionRequest.class));
+
+        System.setOut(System.out);
     }
 
     @Test
     public void getAliasVersion() {
-        // TODO
+        String aliasType = "aliasType";
+        String aliasVersion = "0.1";
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaFileHandler.class);
+        when(abstractLambdaHandler.getAliasVersion(aliasType)).thenCallRealMethod();
+        when(abstractLambdaHandler.getAliasVersion(aliasType, true)).thenReturn(aliasVersion);
+        assertEquals(aliasVersion, abstractLambdaHandler.getAliasVersion(aliasType));
+        verify(abstractLambdaHandler).getAliasVersion(aliasType, true);
+        verify(abstractLambdaHandler).getAliasVersion(aliasType);
     }
 
     @Test
     public void getAliasVersionWithTwoArguments() {
-        // TODO
+        OutputStream os = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(os);
+        System.setOut(ps);
+
+        String functionName = "Lambda";
+        String aliasType = "aliasType";
+        String aliasVersion = "0.1";
+        AWSLambda awsLambda = mock(AWSLambda.class);
+        GetAliasResult getAliasResult = mock(GetAliasResult.class);
+        AbstractLambdaHandler abstractLambdaHandler = spy(new AbstractLambdaHandler(functionName, awsLambda) {});
+
+        when(awsLambda.getAlias(any(GetAliasRequest.class)))
+                .thenThrow(new AmazonClientException("Amazon client Exception"))
+                .thenReturn(getAliasResult);
+        when(getAliasResult.getFunctionVersion()).thenReturn(aliasVersion);
+
+        assertNull(abstractLambdaHandler.getAliasVersion(aliasType, true));
+        String printOut = String.format("^error^ Alias [ %s ] does not exist for Lambda function [ %s ]^r^%n", aliasType, functionName);
+        assertEquals(printOut, os.toString());
+        assertEquals(aliasVersion, abstractLambdaHandler.getAliasVersion(aliasType, true));
+        verify(abstractLambdaHandler, times(2)).getAliasVersion(aliasType, true);
+        verify(awsLambda, times(2)).getAlias(any(GetAliasRequest.class));
+        verify(getAliasResult).getFunctionVersion();
+
+        System.setOut(System.out);
     }
 
 }
diff --git a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java
@@ -1,6 +1,21 @@
 package org.facil.practice;
 
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
 
 /**
  * User: blangel
@@ -9,14 +24,71 @@
  */
 public class DefaultFileHandlerTest {
 
+    private final OutputStream outputStream = new ByteArrayOutputStream();
+    private final PrintStream printStream = new PrintStream(outputStream);
+
+    @Before
+    public void setup() {
+        System.setOut(printStream);
+    }
+
+    @After
+    public void tearDown() {
+        System.setOut(System.out);
+    }
+
     @Test
-    public void saveFile() {
-        // TODO
+    public void saveFile() throws IOException {
+        String version = "0.1";
+        String fileName = "aFile";
+        File file = spy(new File(fileName));
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+
+        when(file.getName()).thenReturn(fileName);
+        assertFalse(defaultFileHandler.saveFile(null, version));
+        assertFalse(defaultFileHandler.saveFile(file, null));
+        assertTrue(defaultFileHandler.saveFile(file, version));
+
+        when(file.getPath()).thenAnswer(new Answer() {
+            @Override public Object answer(InvocationOnMock invocation) throws Throwable {
+                throw new IOException();
+            }
+        });
+        assertFalse(defaultFileHandler.saveFile(file, version));
+        String errInfo = String.format("^error^ Could not write version [ %s ] into file [ %s]^r^%n", version, file.getName());
+        assertEquals(errInfo, outputStream.toString());
+        verify(file, times(2)).getPath();
+        verify(file, times(2)).getName();
+
+        file.deleteOnExit();
     }
 
     @Test
-    public void readFile() {
-        // TODO
+    public void readFile() throws IOException {
+        String fileName = "aFile";
+        String content = "first line";
+        File file = spy(new File(fileName));
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+
+        when(file.getName()).thenReturn(fileName);
+        assertNull(defaultFileHandler.readFile(null));
+        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
+        writer.write(content);
+        writer.close();
+        String readContent = defaultFileHandler.readFile(file);
+        assertEquals(content, readContent);
+
+        when(file.getPath()).thenAnswer(new Answer() {
+            @Override public Object answer(InvocationOnMock invocation) throws Throwable {
+                throw new IOException();
+            }
+        });
+        assertNull(defaultFileHandler.readFile(file));
+        String errInfo = String.format("^error^ Cannot read file [ %s ]^r^%n", file.getName());
+        assertEquals(errInfo, outputStream.toString());
+
+        verify(file, times(2)).getName();
+        file.deleteOnExit();
     }
 
 }
diff --git a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java
@@ -1,7 +1,20 @@
 package org.facil.practice;
 
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.services.lambda.AWSLambda;
+import com.amazonaws.services.lambda.model.PublishVersionRequest;
+import com.amazonaws.services.lambda.model.PublishVersionResult;
 import org.junit.Test;
 
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
 /**
  * User: blangel
  * Date: 12/31/15
@@ -10,13 +23,69 @@
 public class LambdaFunctionPublishTest {
 
     @Test
-    public void publishVersion() {
-        // TODO
+    public void publishVersion() throws NoSuchMethodException {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        PrintStream printStream = new PrintStream(outputStream);
+        System.setOut(printStream);
+        String functionName = "Test";
+        String versionDescription = "Latest";
+        String fileName = "aFile";
+
+        AWSLambda awsLambda = mock(AWSLambda.class);
+        File file = mock(File.class);
+        FileHandler fileHandler = mock(FileHandler.class);
+        PublishVersionResult publishVersionResult = mock(PublishVersionResult.class);
+        LambdaFunctionPublish lambdaFunctionPublish
+                = spy(new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler));
+        Method publishVersion = LambdaFunctionPublish.class.getDeclaredMethod("publishVersion");
+        publishVersion.setAccessible(true);
+        when(awsLambda.publishVersion(any(PublishVersionRequest.class)))
+                .thenThrow(new AmazonClientException("Amazon Client Exception"))
+                .thenReturn(publishVersionResult);
+
+        try {
+            assertNull(publishVersion.invoke(lambdaFunctionPublish));
+            String errInfo = String.format("^error^ Lambda function [ %s ] does not exist^r^%n", functionName);
+            assertEquals(errInfo, outputStream.toString());
+            assertEquals(publishVersionResult, publishVersion.invoke(lambdaFunctionPublish));
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            fail("should not throw Exceptions here");
+        }
+        verify(awsLambda, times(2)).publishVersion(any(PublishVersionRequest.class));
+
+        System.setOut(System.out);
     }
 
     @Test
     public void publishNewVersion() {
-        // TODO
+        String functionName = "Test";
+        String versionDescription = "Latest";
+        String fileName = "aFile";
+        String version = "0.1";
+        AWSLambda awsLambda = mock(AWSLambda.class);
+        File file = mock(File.class);
+        FileHandler fileHandler = spy(new DefaultFileHandler());
+        PublishVersionResult publishVersionResult = mock(PublishVersionResult.class);
+        LambdaFunctionPublish lambdaFunctionPublish
+                = spy(new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler));
+
+        when(awsLambda.publishVersion(any(PublishVersionRequest.class)))
+                .thenReturn(publishVersionResult);
+        when(publishVersionResult.getVersion()).thenReturn(version);
+        doReturn(false).doReturn(true).when(lambdaFunctionPublish).createFileIfNotExists();
+        doReturn(false).doReturn(true).when(lambdaFunctionPublish).doesLambdaFunctionExist();
+        doReturn(true).when(fileHandler).saveFile(file, version);
+
+        assertFalse(lambdaFunctionPublish.publishNewVersion());
+        assertFalse(lambdaFunctionPublish.publishNewVersion());
+        assertTrue(lambdaFunctionPublish.publishNewVersion());
+
+        verify(lambdaFunctionPublish, times(3)).publishNewVersion();
+        verify(lambdaFunctionPublish, times(3)).createFileIfNotExists();
+        verify(lambdaFunctionPublish, times(2)).doesLambdaFunctionExist();
+        verify(fileHandler).saveFile(file, version);
+        verify(awsLambda).publishVersion(any(PublishVersionRequest.class));
+        verify(publishVersionResult).getVersion();
     }
 
 }