diff --git a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java index 16104d4..0ab03e8 100644 --- 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 index 24dcb65..734e894 100644 --- 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 index 5e68958..537aa50 100644 --- 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(); } } diff --git a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java index 618b2c7..cc73689 100644 --- a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java +++ b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java @@ -1,6 +1,23 @@ package org.facil.practice; +import com.amazonaws.AmazonClientException; +import com.amazonaws.services.lambda.AWSLambda; +import com.amazonaws.services.lambda.model.GetFunctionRequest; +import com.amazonaws.services.lambda.model.PublishVersionRequest; +import com.amazonaws.services.lambda.model.PublishVersionResult; import org.junit.Test; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import java.io.File; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import static junit.framework.Assert.*; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.*; /** * User: blangel @@ -10,13 +27,227 @@ public class LambdaFunctionPublishTest { @Test - public void publishVersion() { - // TODO + public void publishVersion() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, + InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class); + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, + fileName, versionDescription, fileHandler, file); + Method publishVersion = lambdaFunctionPublish.getClass().getDeclaredMethod("publishVersion",null); + publishVersion.setAccessible(true); + assertNotNull(publishVersion.invoke(lambdaFunctionPublish, null)); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); + } + + @Test + public void publishVersionCheckPublishVersionResultObject() throws NoSuchMethodException, InvocationTargetException, + IllegalAccessException, InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class); + PublishVersionResult publishVersionResult = mock(PublishVersionResult.class); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenReturn(publishVersionResult); + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, + versionDescription, fileHandler, file); + Method publishVersion = lambdaFunctionPublish.getClass().getDeclaredMethod("publishVersion",null); + publishVersion.setAccessible(true); + assertEquals(publishVersionResult, publishVersion.invoke(lambdaFunctionPublish, null)); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); + } + + @Test + public void PublishVersionCheckVersion() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, + InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + String version = "Version 9.08"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class); + PublishVersionResult publishVersionResult = mock(PublishVersionResult.class); + when(publishVersionResult.getVersion()).thenReturn(version); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenReturn(publishVersionResult); + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, + versionDescription, fileHandler, file); + Method publishVersion = lambdaFunctionPublish.getClass().getDeclaredMethod("publishVersion",null); + publishVersion.setAccessible(true); + PublishVersionResult publishVersionResultLocal = (PublishVersionResult) publishVersion.invoke(lambdaFunctionPublish, null); + assertEquals(version, publishVersionResultLocal.getVersion()); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); } + @SuppressWarnings("unchecked") @Test - public void publishNewVersion() { - // TODO + public void publishVersionWhenExceptionReturnNull() throws NoSuchMethodException, InvocationTargetException, + IllegalAccessException, InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class); + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, + versionDescription, fileHandler, file); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenThrow(AmazonClientException.class); + Method publishVersion = lambdaFunctionPublish.getClass().getDeclaredMethod("publishVersion",null); + publishVersion.setAccessible(true); + assertNull(publishVersion.invoke(lambdaFunctionPublish, null)); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); + } + + + + @Test + public void publishNewVersion() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, + InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class);// RETURNS_DEEP_STUBS can also be used instead of mocking PublishVersionResult + //then returning it when awsLambda.publishVersion is called. + String functionName = "getSomething"; + String fileName = "test.txt"; + String version = "9.9"; + String versionDescription = "This version adds new functionality"; + //using answer seems more appropriate here than using when + FileHandler fileHandler = mock(DefaultFileHandler.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("saveFile")){ + return Boolean.TRUE; + } + return invocation.callRealMethod(); } + }); + File file = mock(File.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("exists")){ + return Boolean.TRUE; + } + return invocation.callRealMethod(); + } + }); + + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, + versionDescription, fileHandler, file); + PublishVersionResult publishVersionResult = mock(PublishVersionResult.class); + when(publishVersionResult.getVersion()).thenReturn(version); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenReturn(publishVersionResult); + assertTrue(lambdaFunctionPublish.publishNewVersion()); + verify(file).exists(); + verify(fileHandler).saveFile(file, version); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); } + @SuppressWarnings("unchecked") + @Test + public void publishNewVersionFalseWhenPublishResultIsNull() + throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { + AWSLambda awsLambda = mock(AWSLambda.class); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("saveFile")){ + return Boolean.TRUE; + } + return invocation.callRealMethod(); + } + }); + File file = mock(File.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("exists")){ + return Boolean.TRUE; + } + return invocation.callRealMethod(); + } + }); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenReturn(null); + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, + versionDescription, fileHandler, file); + assertFalse(lambdaFunctionPublish.publishNewVersion()); + verify(file).exists(); + // fileHandler.saveFile should not be invoked because implementation uses short circuit && + //so return statement should return false immediately when it sees result != null + verify(fileHandler, never()).saveFile((File) any() , (String) any()); + verify(awsLambda).publishVersion((PublishVersionRequest) any()); + } + + + @Test + public void publishNewVersionFalseWhenCreateFileNotExistsFalse() throws NoSuchFieldException, IllegalAccessException, + NoSuchMethodException, InvocationTargetException, InstantiationException, IOException { + AWSLambda awsLambda = mock(AWSLambda.class); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("createNewFile")){ + return Boolean.FALSE; + } + if(invocation.getMethod().getName().equals("exists")){ + return Boolean.FALSE; + } + return invocation.callRealMethod(); + } + }); + PublishVersionResult publishVersionResult = mock(PublishVersionResult.class); + when(awsLambda.publishVersion((PublishVersionRequest) any())).thenReturn(publishVersionResult); + + LambdaFunctionPublish lambdaFunctionPublish = getLambdaFunctionPublish(awsLambda, functionName, fileName, versionDescription, fileHandler, file); + assertFalse(lambdaFunctionPublish.publishNewVersion()); + verify(file).exists(); + verify(file).createNewFile(); + verify(fileHandler, never()).saveFile((File) any(), (String) any()); + verify(awsLambda, never()).publishVersion((PublishVersionRequest) any()); + } + + @SuppressWarnings("unchecked") + @Test + public void publishNewVersionFalseWhenDoesLambdaFunctionExistsFalse() + throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException { + AWSLambda awsLambda = mock(AWSLambda.class); + String functionName = "getSomething"; + String fileName = "test.txt"; + String versionDescription = "This version adds new functionality"; + FileHandler fileHandler = mock(DefaultFileHandler.class); + File file = mock(File.class, new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if(invocation.getMethod().getName().equals("exists")){ + return Boolean.TRUE; + } + return invocation.callRealMethod(); + } + }); + LambdaFunctionPublish lambdaFunctionPublish = spy(new LambdaFunctionPublish(functionName, versionDescription, + awsLambda, fileName, file, fileHandler)); + when(awsLambda.getFunction((GetFunctionRequest) any())).thenThrow(AmazonClientException.class); + assertFalse(lambdaFunctionPublish.publishNewVersion()); + verify(file).exists(); + verify(file, never()).createNewFile(); + verify(awsLambda).getFunction((GetFunctionRequest) any()); + verify(fileHandler, never()).saveFile((File) any(), (String) any()); + } + + + private LambdaFunctionPublish getLambdaFunctionPublish(AWSLambda awsLambda, String functionName, String fileName, + String versionDescription, FileHandler fileHandler, File file) + throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException { + Constructor constructor = LambdaFunctionPublish.class.getDeclaredConstructor(String.class, String.class, AWSLambda.class, + String.class, File.class, FileHandler.class); + constructor.setAccessible(true); + return (LambdaFunctionPublish) constructor.newInstance(functionName, versionDescription, awsLambda, fileName, file, fileHandler); + } } diff --git a/src/test/java/org/facil/practice/ReflectionUtils.java b/src/test/java/org/facil/practice/ReflectionUtils.java new file mode 100644 index 0000000..99c01e9 --- /dev/null +++ b/src/test/java/org/facil/practice/ReflectionUtils.java @@ -0,0 +1,31 @@ +package org.facil.practice; + +import java.lang.reflect.Field; + +/** + * Created by sumanthdommaraju on 1/1/16. + */ +public class ReflectionUtils { + + public static void setNonAccessibleField(Object object, String fieldName, Object value) throws IllegalAccessException, + NoSuchFieldException { + Field field = getField(object.getClass(), fieldName); + field.setAccessible(true); + field.set(object, value); + } + + private static Field getField(Class clazz, String fieldName) throws NoSuchFieldException { + Field field = null; + for(Class cls = clazz; cls != null; cls = cls.getSuperclass()){ + try{ + field = cls.getDeclaredField(fieldName); + }catch (NoSuchFieldException nsme){ + //If not ignored cannot walk through class hierarchy + } + } + if(field == null){ + throw new NoSuchFieldException(); + } + return field; + } +}