facillang · svd260 · Jan 6, 2016 · Jan 6, 2016 · Jan 10, 2016 · Jan 16, 2016
diff --git a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java
@@ -2,6 +2,14 @@
 
 import org.junit.Test;
 
+import java.io.File;
+import java.io.IOException;
+
+import static org.facil.practice.ReflectionUtils.setNonAccessibleField;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.*;
+
 /**
  * User: blangel
  * Date: 12/31/15
@@ -10,8 +18,67 @@
 public class AbstractLambdaFileHandlerTest {
 
     @Test
-    public void createFileIfNotExists() {
-        // TODO
+    public void createFileIfNotExists() throws IOException, NoSuchFieldException, IllegalAccessException {
+        File file = mock(File.class);
+        when(file.exists()).thenReturn(Boolean.FALSE);
+        when(file.createNewFile()).thenReturn(Boolean.TRUE);
+        AbstractLambdaFileHandler abstractLambdaFileHandler = mock(AbstractLambdaFileHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaFileHandler, "file", file);
+        assertTrue(abstractLambdaFileHandler.createFileIfNotExists());
+        verify(file,times(1)).exists();
+        verify(file,times(1)).createNewFile();
+    }
+
+
+    @Test
+    public void donotCreateNewFileIfExists() throws IOException, NoSuchFieldException, IllegalAccessException {
+        File file = mock(File.class);
+        when(file.exists()).thenReturn(Boolean.TRUE);
+        when(file.createNewFile()).thenReturn(Boolean.FALSE);
+        AbstractLambdaFileHandler abstractLambdaFileHandler = mock(AbstractLambdaFileHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaFileHandler, "file", file);
+        assertTrue(abstractLambdaFileHandler.createFileIfNotExists());
+        verify(file,times(1)).exists();
+        verify(file,never()).createNewFile();
+    }
+
+    @Test
+    public void donotCreateFileWhenFileOperationsReturnFalse() throws NoSuchFieldException, IllegalAccessException, IOException {
+        String fileName = "test.txt";
+        File file = mock(File.class);
+        when(file.exists()).thenReturn(Boolean.FALSE);
+        when(file.createNewFile()).thenReturn(Boolean.FALSE);
+        AbstractLambdaFileHandler abstractLambdaFileHandler = mock(AbstractLambdaFileHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaFileHandler, "file", file);
+        setNonAccessibleField(abstractLambdaFileHandler, "fileName", fileName);
+        assertFalse(abstractLambdaFileHandler.createFileIfNotExists());
+        verify(file,times(1)).exists();
+        verify(file,times(1)).createNewFile();
+    }
+
+    @Test(expected = IOException.class)
+    public void createFileIfNotExistsWhenExceptionForFileOperations() throws NoSuchFieldException, IllegalAccessException, IOException {
+        File file = mock(File.class);
+        when(file.exists()).thenThrow(IOException.class);
+        AbstractLambdaFileHandler abstractLambdaFileHandler = mock(AbstractLambdaFileHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaFileHandler, "file", file);
+        abstractLambdaFileHandler.createFileIfNotExists();
+        verify(file,times(1)).exists();
+        verify(file,never()).createNewFile();
+    }
+
+    @Test
+    public void createFileIfNotExistsFalseWhenIOException() throws NoSuchFieldException, IllegalAccessException, IOException {
+        String fileName = "test.txt";
+        File file = mock(File.class);
+        when(file.exists()).thenReturn(Boolean.FALSE);
+        when(file.createNewFile()).thenThrow(IOException.class);
+        AbstractLambdaFileHandler abstractLambdaFileHandler = mock(AbstractLambdaFileHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaFileHandler, "file", file);
+        setNonAccessibleField(abstractLambdaFileHandler, "fileName", fileName);
+        assertFalse(abstractLambdaFileHandler.createFileIfNotExists());
+        verify(file,times(1)).exists();
+        verify(file,times(1)).createNewFile();
     }
 
 }
diff --git a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java
@@ -1,7 +1,22 @@
 package org.facil.practice;
 
+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 org.junit.Test;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNull;
+import static org.facil.practice.ReflectionUtils.setNonAccessibleField;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
 /**
  * User: blangel
  * Date: 12/31/15
@@ -10,23 +25,119 @@
 public class AbstractLambdaHandlerTest {
 
     @Test
-    public void doesLambdaFunctionExist() {
-        // TODO
+    public void doesLambdaFunctionExist() throws NoSuchFieldException, IllegalAccessException {
+        AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+        assertTrue(abstractLambdaHandler.doesLambdaFunctionExist());
+        verify(awsLambda).getFunction((GetFunctionRequest) any());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void doesLambdaFunctionExistWhenException() throws NoSuchFieldException, IllegalAccessException {
+        AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+        setNonAccessibleField(abstractLambdaHandler,"functionName", "getSomething");
+        when(awsLambda.getFunction((GetFunctionRequest) any())).thenThrow(AmazonClientException.class);
+        assertFalse(abstractLambdaHandler.doesLambdaFunctionExist());
+        verify(awsLambda).getFunction((GetFunctionRequest) any());
+    }
+
+    //Obviously not a good test case(because verifying a print message is error prone).
+    // Couldn't able to test in any other way because it is an overloaded method(the method that has implementation already been tested)
+    // with just a flag to print a message.
+    @SuppressWarnings("unchecked")
+    @Test
+    public void doesLambdaFunctionExistWithArgument() throws IOException, NoSuchFieldException, IllegalAccessException {
+        PrintStream stdOut = System.out;
+        try(ByteArrayOutputStream content = new ByteArrayOutputStream()) {
+            System.setOut(new PrintStream(content));
+            AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+            String functionName = "getSomething";
+            when(awsLambda.getFunction((GetFunctionRequest) any())).thenThrow(AmazonClientException.class);
+            AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+            setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+            setNonAccessibleField(abstractLambdaHandler,"functionName", functionName);
+            abstractLambdaHandler.doesLambdaFunctionExist(true);
+            assertEquals(String.format("^error^ Lambda function [ %s ] does not exist^r^%n", functionName), content.toString());
+        }finally {
+            System.setOut(stdOut);
+        }
     }
 
+
     @Test
-    public void doesLambdaFunctionExistWithArgument() {
-        // TODO
+    public void getAliasVersion() throws NoSuchFieldException, IllegalAccessException {
+        AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+        GetAliasResult getAliasResult = mock(GetAliasResult.class);
+        String functionVersion = "10.9";
+        String aliasType = "someAliasType";
+        when(getAliasResult.getFunctionVersion()).thenReturn(functionVersion);
+        when(awsLambda.getAlias((GetAliasRequest) any())).thenReturn(getAliasResult);
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+        assertEquals(functionVersion, abstractLambdaHandler.getAliasVersion(aliasType));
+        verify(awsLambda, times(1)).getAlias((GetAliasRequest) any());
+        verify(getAliasResult, times(1)).getFunctionVersion();
     }
 
     @Test
-    public void getAliasVersion() {
-        // TODO
+    public void getAliasVersionNotSame() throws NoSuchFieldException, IllegalAccessException {
+        AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+        GetAliasResult getAliasResult = mock(GetAliasResult.class);
+        String functionVersion = "10.9";
+        String aliasType = "someAliasType";
+        when(getAliasResult.getFunctionVersion()).thenReturn(functionVersion);
+        when(awsLambda.getAlias((GetAliasRequest) any())).thenReturn(getAliasResult);
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+        assertNotSame("10.8", abstractLambdaHandler.getAliasVersion(aliasType));
+        verify(awsLambda, times(1)).getAlias((GetAliasRequest) any());
+        verify(getAliasResult, times(1)).getFunctionVersion();
     }
 
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void getAliasVersionWhenException() throws NoSuchFieldException, IllegalAccessException {
+        AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+        when(awsLambda.getAlias((GetAliasRequest) any())).thenThrow(AmazonClientException.class);
+        GetAliasResult getAliasResult = mock(GetAliasResult.class);
+        String aliasType = "someAliasType";
+        String functionName = "getSomething";
+        AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+        setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+        setNonAccessibleField(abstractLambdaHandler,"functionName", functionName);
+        assertNull(abstractLambdaHandler.getAliasVersion(aliasType));
+        verify(awsLambda).getAlias((GetAliasRequest) any());
+        verify(getAliasResult, never()).getFunctionVersion();
+    }
+
+
+    //Obviously not a good test case(because verifying a print message is error prone).
+    // Looks like there is no other way to test because it is just a overloaded method
+    // with just a flag to print a message.
+    @SuppressWarnings("unchecked")
     @Test
-    public void getAliasVersionWithTwoArguments() {
-        // TODO
+    public void getAliasVersionWithTwoArguments() throws IOException, NoSuchFieldException, IllegalAccessException {
+        PrintStream stdOut = System.out;
+        try(ByteArrayOutputStream content = new ByteArrayOutputStream()) {
+            System.setOut(new PrintStream(content));
+            AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS);
+            String aliasType = "someAliasType";
+            String functionName = "getSomething";
+            AbstractLambdaHandler abstractLambdaHandler = mock(AbstractLambdaHandler.class, CALLS_REAL_METHODS);
+            setNonAccessibleField(abstractLambdaHandler,"awsLambda", awsLambda);
+            setNonAccessibleField(abstractLambdaHandler,"functionName", functionName);
+            when(awsLambda.getAlias((GetAliasRequest) any())).thenThrow(AmazonClientException.class);
+            abstractLambdaHandler.getAliasVersion(aliasType, true);
+            assertEquals(String.format("^error^ Alias [ %s ] does not exist for Lambda function [ %s ]^r^%n", aliasType,
+                                                    functionName), content.toString());
+        }finally {
+            System.setOut(stdOut);
+        }
     }
 
 }
diff --git a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java
@@ -1,6 +1,16 @@
 package org.facil.practice;
 
 import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 /**
  * User: blangel
@@ -10,13 +20,118 @@
 public class DefaultFileHandlerTest {
 
     @Test
-    public void saveFile() {
-        // TODO
+    public void SaveFileNullArgs(){
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertFalse(defaultFileHandler.saveFile(null, null));
+    }
+
+    @Test
+    public void SaveFileNullArgForFile(){
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertFalse(defaultFileHandler.saveFile(null, "version 9.9"));
+    }
+
+    @Test
+    public void SaveFileNullArgForVersion(){
+        File file = mock(File.class);
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertFalse(defaultFileHandler.saveFile(file, null));
+    }
+
+    @Test
+    public void saveFile() throws NoSuchFieldException, IllegalAccessException {
+        File file = spy(new File("test"));
+        String version = "9.9";
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertTrue(defaultFileHandler.saveFile(file,version));
+        verify(file).getPath();
+        if(file.exists()){
+            file.delete();
+        }
+    }
+
+    @Test
+    public void saveFileVerifyFileExists() throws Exception {
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        File file = spy(new File("test"));
+        defaultFileHandler.saveFile(file, "version 9.9");
+        assertTrue(file.exists());
+        verify(file).getPath();
+        if(file.exists()){
+            file.delete();
+        }
+    }
+
+    @Test
+    public void SaveFileIOException(){
+        //using answer seems more appropriate here than using when
+        File file = mock(File.class, new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                if(invocation.getMethod().getName().equals("getName")){
+                    return "test";
+                }else{
+                    throw new IOException();
+                }
+            }
+        });
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertFalse(defaultFileHandler.saveFile(file, "version 9.9"));
+        verify(file).getName();
+    }
+
+    @Test
+    public void readFileNullArgForFile(){
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertNull(defaultFileHandler.readFile(null));
+    }
+
+    @Test
+    public void readFile() throws IOException {
+        String version = "version 9.9";
+        File file = spy(new File("test.txt"));
+        try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file))) {
+            bufferedWriter.write(version);
+        }
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertEquals(version, defaultFileHandler.readFile(file));
+        if(file.exists()){
+            file.delete();
+        }
+        verify(file, times(2)).getPath();
+    }
+
+
+    @Test
+    public void readFileNotSame() throws IOException {
+        String version = "version 9.9";
+        File file = spy(new File("test.txt"));
+        try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file))) {
+            bufferedWriter.write(version);
+        }
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertNotSame("version 9.8", defaultFileHandler.readFile(file));
+        if(file.exists()){
+            file.delete();
+        }
+        verify(file, times(2)).getPath();
     }
 
     @Test
-    public void readFile() {
-        // TODO
+    public void readFileIOException(){
+        File file = mock(File.class, new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                if(invocation.getMethod().getName().equals("getName")){
+                    return "test";
+                }else{
+                    throw new IOException();
+                }
+            }
+        });
+        DefaultFileHandler defaultFileHandler = new DefaultFileHandler();
+        assertNull(defaultFileHandler.readFile(file));
+        verify(file).getName();
     }
 
 }