From d6d6b3d66bd72a320a3417b1043dc6a0029be8f4 Mon Sep 17 00:00:00 2001 From: liranjiao Date: Mon, 15 Feb 2016 18:32:17 -0800 Subject: [PATCH 1/2] Finish Practice Test --- .../AbstractLambdaFileHandlerTest.java | 58 +++++++++++++++ .../practice/AbstractLambdaHandlerTest.java | 66 +++++++++++++++++ .../practice/DefaultFileHandlerTest.java | 39 +++++++++- .../practice/LambdaFunctionPublishTest.java | 71 +++++++++++++++++++ 4 files changed, 232 insertions(+), 2 deletions(-) diff --git a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java index 16104d4..0889115 100644 --- 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 com.amazonaws.services.lambda.AWSLambda; +import static org.mockito.Mockito.*; +import static org.junit.Assert.*; +import org.junit.Before; 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 @@ -9,9 +18,58 @@ */ public class AbstractLambdaFileHandlerTest { + //Use an inheritance class to test the abstract class + class AbstractClassImplement extends AbstractLambdaFileHandler{ + public AbstractClassImplement(String functionName, String fileName, File file, AWSLambda awsLambda){ + super(functionName, fileName, file, awsLambda); + } + } + + String functionName; + String fileName; + File file; + AWSLambda awsLambda; + AbstractClassImplement abstractLambdaFileHandler; + + @Before + public void initialize(){ + functionName = "FunctionName"; + fileName = "FileName"; + file = mock(File.class); + awsLambda = mock(AWSLambda.class); + abstractLambdaFileHandler = new AbstractClassImplement(functionName, fileName, file, awsLambda); + } + @Test public void createFileIfNotExists() { // TODO + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + System.setOut(new PrintStream(outContent)); + String errorMessage = "^error^ Could not create file [ FileName ]^r^"; + + + when(file.exists()).thenReturn(true); + assertTrue(abstractLambdaFileHandler.createFileIfNotExists()); + when(file.exists()).thenReturn(false); + try { + when(file.createNewFile()).thenReturn(true); + }catch (IOException e){} + assertTrue(abstractLambdaFileHandler.createFileIfNotExists()); + + try { + when(file.createNewFile()).thenReturn(false); + }catch (IOException e){} + assertTrue(!abstractLambdaFileHandler.createFileIfNotExists()); + assertTrue(outContent.toString().indexOf(errorMessage) >= 0); + + try { + doThrow(new IOException("UnitTest")).when(file).createNewFile(); + }catch (IOException e){ + assertTrue(!abstractLambdaFileHandler.createFileIfNotExists()); + assertTrue(outContent.toString().indexOf(errorMessage) >= 0); + } + + } } diff --git a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java index 24dcb65..9add124 100644 --- a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java +++ b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java @@ -1,5 +1,16 @@ package org.facil.practice; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.*; +import static org.junit.Assert.*; + +import java.io.*; + +import com.amazonaws.AmazonClientException; +import com.amazonaws.services.lambda.AWSLambda; +import com.amazonaws.services.lambda.model.GetAliasResult; +import org.junit.Before; import org.junit.Test; /** @@ -9,24 +20,79 @@ */ public class AbstractLambdaHandlerTest { + //Use an inheritance class to test the abstract class + class AbstractClassImplement extends AbstractLambdaHandler{ + public AbstractClassImplement(String functionName, AWSLambda awsLambda){ + super(functionName, awsLambda); + } + } + + AbstractLambdaHandler mockAbstractLambdaHandler; + String functionName; + AWSLambda awsLambda; + AbstractClassImplement abstractClassImplement; + + @Before + public void initialize(){ + functionName = "FunctionName"; + awsLambda = mock(AWSLambda.class); + mockAbstractLambdaHandler = mock(AbstractLambdaHandler.class); + abstractClassImplement = new AbstractClassImplement(functionName, awsLambda); + } + @Test public void doesLambdaFunctionExist() { // TODO + when(mockAbstractLambdaHandler.doesLambdaFunctionExist()).thenCallRealMethod(); + doReturn(true).when(mockAbstractLambdaHandler).doesLambdaFunctionExist(true); + assertEquals(mockAbstractLambdaHandler.doesLambdaFunctionExist(), true); } @Test public void doesLambdaFunctionExistWithArgument() { // TODO + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + System.setOut(new PrintStream(outContent)); + String errorMessage = "^error^ Lambda function [ FunctionName ] does not exist^r^"; + + when(awsLambda.getFunction(any())).thenReturn(any()); + assertEquals(abstractClassImplement.doesLambdaFunctionExist(true), true); + + doThrow(new AmazonClientException("UnitTest")).when(awsLambda).getFunction(any()); + assertEquals(abstractClassImplement.doesLambdaFunctionExist(false), false); + + + assertEquals(abstractClassImplement.doesLambdaFunctionExist(true), false); + assertTrue(outContent.toString().indexOf(errorMessage) >= 0); } @Test public void getAliasVersion() { // TODO + String aliasType = "AliasType"; + when(mockAbstractLambdaHandler.getAliasVersion(aliasType)).thenCallRealMethod(); + doReturn(aliasType).when(mockAbstractLambdaHandler).getAliasVersion(aliasType, true); + assertEquals(mockAbstractLambdaHandler.getAliasVersion(aliasType), aliasType); } @Test public void getAliasVersionWithTwoArguments() { // TODO + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + System.setOut(new PrintStream(outContent)); + String functionVersion = "FunctionVersion"; + String aliasType = "AliasType"; + String errorMessage = "^error^ Alias [ AliasType ] does not exist for Lambda function [ FunctionName ]^r^"; + + GetAliasResult getAliasResult = mock(GetAliasResult.class); + when(awsLambda.getAlias(any())).thenReturn(getAliasResult); + when(getAliasResult.getFunctionVersion()).thenReturn(functionVersion); + assertEquals(abstractClassImplement.getAliasVersion(aliasType, true), functionVersion); + + doThrow(new AmazonClientException("Exception")).when(awsLambda).getAlias(any()); + assertEquals(abstractClassImplement.getAliasVersion(aliasType, false), null); + assertEquals(abstractClassImplement.getAliasVersion(aliasType, true), null); + assertTrue(outContent.toString().indexOf(errorMessage) >= 0); } } diff --git a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java index 5e68958..ccdedbd 100644 --- a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java +++ b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java @@ -1,5 +1,11 @@ package org.facil.practice; +import static org.mockito.Mockito.*; +import static org.junit.Assert.*; + +import java.io.*; + +import org.junit.Before; import org.junit.Test; /** @@ -9,14 +15,43 @@ */ public class DefaultFileHandlerTest { + String version; + BufferedReader mockBufferedReader; + BufferedWriter mockBufferedWritter; + DefaultFileHandler defaultFileHandlerTest; + + @Before + public void initialize() { + version = "version"; + mockBufferedWritter = mock(BufferedWriter.class); + mockBufferedReader = mock(BufferedReader.class); + defaultFileHandlerTest = new DefaultFileHandler(mockBufferedWritter, mockBufferedReader); + + } + @Test - public void saveFile() { + public void saveFile() throws Exception { // TODO + assertEquals(defaultFileHandlerTest.saveFile(null), false); + + doNothing().when(mockBufferedWritter).write(anyString()); + assertEquals(defaultFileHandlerTest.saveFile(version), true); + + doThrow(new IOException()).when(mockBufferedWritter).write(anyString()); + assertEquals(defaultFileHandlerTest.saveFile(version), false); + } @Test - public void readFile() { + public void readFile() throws Exception { // TODO + doReturn(version).when(mockBufferedReader).readLine(); + assertEquals(defaultFileHandlerTest.readFile(), version); + + doThrow(new IOException()).when(mockBufferedReader).readLine(); + assertEquals(defaultFileHandlerTest.readFile(), null); } + + } diff --git a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java index 618b2c7..d420b28 100644 --- a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java +++ b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java @@ -1,7 +1,18 @@ package org.facil.practice; +import com.amazonaws.AmazonClientException; +import com.amazonaws.services.lambda.AWSLambda; +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.*; +import static org.junit.Assert.*; + +import com.amazonaws.services.lambda.model.GetFunctionResult; +import com.amazonaws.services.lambda.model.PublishVersionResult; +import org.junit.Before; import org.junit.Test; +import java.io.*; + /** * User: blangel * Date: 12/31/15 @@ -9,14 +20,74 @@ */ public class LambdaFunctionPublishTest { + String functionName; + String versionDescription; + String fileName; + BufferedWriter bufferedWriter; + BufferedReader bufferedReader; + AWSLambda awsLambda; + File file; + FileHandler fileHandler; + LambdaFunctionPublish lambdaFunctionPublish; + + @Before + public void initialize(){ + functionName = "FunctionName"; + versionDescription = "VersionDescription"; + fileName = "FileName"; + bufferedWriter = mock(BufferedWriter.class); + bufferedReader = mock(BufferedReader.class); + awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); + file = mock(File.class); + fileHandler = mock(FileHandler.class); + lambdaFunctionPublish = new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler); + } + @Test public void publishVersion() { // TODO + when(file.exists()).thenReturn(false); + assertTrue(!lambdaFunctionPublish.publishNewVersion()); + + when(file.exists()).thenReturn(true); + doThrow(new AmazonClientException("UnitTest")).when(awsLambda).getFunction(any()); + assertTrue(!lambdaFunctionPublish.publishNewVersion()); + + doReturn(new GetFunctionResult()).when(awsLambda).getFunction(any()); + when(awsLambda.publishVersion(any())).thenReturn(new PublishVersionResult()); + when(fileHandler.saveFile(any())).thenReturn(true); + assertTrue(lambdaFunctionPublish.publishNewVersion()); + + doReturn(new GetFunctionResult()).when(awsLambda).getFunction(any()); + when(awsLambda.publishVersion(any())).thenReturn(new PublishVersionResult()); + when(fileHandler.saveFile(any())).thenReturn(false); + assertTrue(!lambdaFunctionPublish.publishNewVersion()); + + doReturn(new GetFunctionResult()).when(awsLambda).getFunction(any()); + when(awsLambda.publishVersion(any())).thenReturn(null); + when(fileHandler.saveFile(any())).thenReturn(true); + assertTrue(!lambdaFunctionPublish.publishNewVersion()); + + } @Test public void publishNewVersion() { // TODO + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + System.setOut(new PrintStream(outContent)); + String errorMessage = "^error^ Lambda function [ FunctionName ] does not exist^r^"; + + when(file.exists()).thenReturn(true); + when(fileHandler.saveFile(any())).thenReturn(true); + doReturn(new GetFunctionResult()).when(awsLambda).getFunction(any()); + + when(awsLambda.publishVersion(any())).thenReturn(new PublishVersionResult()); + assertTrue(lambdaFunctionPublish.publishNewVersion()); + + doThrow(new AmazonClientException("UnitTest")).when(awsLambda).publishVersion(any()); + assertTrue(!lambdaFunctionPublish.publishNewVersion()); + assertTrue(outContent.toString().indexOf(errorMessage) >= 0); } } From 8787aee2e4556fc0e87fa5c621cac387b1a0512d Mon Sep 17 00:00:00 2001 From: liranjiao Date: Sat, 20 Feb 2016 12:51:24 -0800 Subject: [PATCH 2/2] Move all the variables into methods --- .../AbstractLambdaFileHandlerTest.java | 22 ++++------- .../practice/AbstractLambdaHandlerTest.java | 24 ++++++------ .../practice/DefaultFileHandlerTest.java | 24 +++++------- .../practice/LambdaFunctionPublishTest.java | 39 ++++++++----------- 4 files changed, 44 insertions(+), 65 deletions(-) diff --git a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java index 0889115..b23c8b2 100644 --- a/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java +++ b/src/test/java/org/facil/practice/AbstractLambdaFileHandlerTest.java @@ -25,24 +25,16 @@ public AbstractClassImplement(String functionName, String fileName, File file, A } } - String functionName; - String fileName; - File file; - AWSLambda awsLambda; - AbstractClassImplement abstractLambdaFileHandler; - - @Before - public void initialize(){ - functionName = "FunctionName"; - fileName = "FileName"; - file = mock(File.class); - awsLambda = mock(AWSLambda.class); - abstractLambdaFileHandler = new AbstractClassImplement(functionName, fileName, file, awsLambda); - } - @Test public void createFileIfNotExists() { // TODO + String functionName = "FunctionName"; + String fileName = "FileName"; + File file = mock(File.class); + AWSLambda awsLambda = mock(AWSLambda.class); + AbstractClassImplement abstractLambdaFileHandler = new AbstractClassImplement(functionName, fileName, file, awsLambda); + + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); System.setOut(new PrintStream(outContent)); String errorMessage = "^error^ Could not create file [ FileName ]^r^"; diff --git a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java index 9add124..2314d43 100644 --- a/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java +++ b/src/test/java/org/facil/practice/AbstractLambdaHandlerTest.java @@ -27,22 +27,11 @@ public AbstractClassImplement(String functionName, AWSLambda awsLambda){ } } - AbstractLambdaHandler mockAbstractLambdaHandler; - String functionName; - AWSLambda awsLambda; - AbstractClassImplement abstractClassImplement; - - @Before - public void initialize(){ - functionName = "FunctionName"; - awsLambda = mock(AWSLambda.class); - mockAbstractLambdaHandler = mock(AbstractLambdaHandler.class); - abstractClassImplement = new AbstractClassImplement(functionName, awsLambda); - } - @Test public void doesLambdaFunctionExist() { // TODO + AbstractLambdaHandler mockAbstractLambdaHandler = mock(AbstractLambdaHandler.class); + when(mockAbstractLambdaHandler.doesLambdaFunctionExist()).thenCallRealMethod(); doReturn(true).when(mockAbstractLambdaHandler).doesLambdaFunctionExist(true); assertEquals(mockAbstractLambdaHandler.doesLambdaFunctionExist(), true); @@ -51,6 +40,10 @@ public void doesLambdaFunctionExist() { @Test public void doesLambdaFunctionExistWithArgument() { // TODO + String functionName = "FunctionName"; + AWSLambda awsLambda = mock(AWSLambda.class); + AbstractClassImplement abstractClassImplement = new AbstractClassImplement(functionName, awsLambda); + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); System.setOut(new PrintStream(outContent)); String errorMessage = "^error^ Lambda function [ FunctionName ] does not exist^r^"; @@ -70,6 +63,8 @@ public void doesLambdaFunctionExistWithArgument() { public void getAliasVersion() { // TODO String aliasType = "AliasType"; + AbstractLambdaHandler mockAbstractLambdaHandler = mock(AbstractLambdaHandler.class); + when(mockAbstractLambdaHandler.getAliasVersion(aliasType)).thenCallRealMethod(); doReturn(aliasType).when(mockAbstractLambdaHandler).getAliasVersion(aliasType, true); assertEquals(mockAbstractLambdaHandler.getAliasVersion(aliasType), aliasType); @@ -78,6 +73,9 @@ public void getAliasVersion() { @Test public void getAliasVersionWithTwoArguments() { // TODO + String functionName = "FunctionName"; + AWSLambda awsLambda = mock(AWSLambda.class); + AbstractClassImplement abstractClassImplement = new AbstractClassImplement(functionName, awsLambda); ByteArrayOutputStream outContent = new ByteArrayOutputStream(); System.setOut(new PrintStream(outContent)); String functionVersion = "FunctionVersion"; diff --git a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java index ccdedbd..785db15 100644 --- a/src/test/java/org/facil/practice/DefaultFileHandlerTest.java +++ b/src/test/java/org/facil/practice/DefaultFileHandlerTest.java @@ -15,23 +15,14 @@ */ public class DefaultFileHandlerTest { - String version; - BufferedReader mockBufferedReader; - BufferedWriter mockBufferedWritter; - DefaultFileHandler defaultFileHandlerTest; - - @Before - public void initialize() { - version = "version"; - mockBufferedWritter = mock(BufferedWriter.class); - mockBufferedReader = mock(BufferedReader.class); - defaultFileHandlerTest = new DefaultFileHandler(mockBufferedWritter, mockBufferedReader); - - } - @Test public void saveFile() throws Exception { // TODO + String version = "version"; + BufferedWriter mockBufferedWritter = mock(BufferedWriter.class); + BufferedReader mockBufferedReader = mock(BufferedReader.class); + DefaultFileHandler defaultFileHandlerTest = new DefaultFileHandler(mockBufferedWritter, mockBufferedReader); + assertEquals(defaultFileHandlerTest.saveFile(null), false); doNothing().when(mockBufferedWritter).write(anyString()); @@ -45,6 +36,11 @@ public void saveFile() throws Exception { @Test public void readFile() throws Exception { // TODO + String version = "version"; + BufferedWriter mockBufferedWritter = mock(BufferedWriter.class); + BufferedReader mockBufferedReader = mock(BufferedReader.class); + DefaultFileHandler defaultFileHandlerTest = new DefaultFileHandler(mockBufferedWritter, mockBufferedReader); + doReturn(version).when(mockBufferedReader).readLine(); assertEquals(defaultFileHandlerTest.readFile(), version); diff --git a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java index d420b28..5641927 100644 --- a/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java +++ b/src/test/java/org/facil/practice/LambdaFunctionPublishTest.java @@ -20,32 +20,17 @@ */ public class LambdaFunctionPublishTest { - String functionName; - String versionDescription; - String fileName; - BufferedWriter bufferedWriter; - BufferedReader bufferedReader; - AWSLambda awsLambda; - File file; - FileHandler fileHandler; - LambdaFunctionPublish lambdaFunctionPublish; - - @Before - public void initialize(){ - functionName = "FunctionName"; - versionDescription = "VersionDescription"; - fileName = "FileName"; - bufferedWriter = mock(BufferedWriter.class); - bufferedReader = mock(BufferedReader.class); - awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); - file = mock(File.class); - fileHandler = mock(FileHandler.class); - lambdaFunctionPublish = new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler); - } - @Test public void publishVersion() { // TODO + String functionName = "FunctionName"; + String versionDescription = "VersionDescription"; + String fileName = "FileName"; + AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); + File file = mock(File.class); + FileHandler fileHandler = mock(FileHandler.class); + LambdaFunctionPublish lambdaFunctionPublish = new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler); + when(file.exists()).thenReturn(false); assertTrue(!lambdaFunctionPublish.publishNewVersion()); @@ -74,6 +59,14 @@ public void publishVersion() { @Test public void publishNewVersion() { // TODO + String functionName = "FunctionName"; + String versionDescription = "VersionDescription"; + String fileName = "FileName"; + AWSLambda awsLambda = mock(AWSLambda.class, RETURNS_DEEP_STUBS); + File file = mock(File.class); + FileHandler fileHandler = mock(FileHandler.class); + LambdaFunctionPublish lambdaFunctionPublish = new LambdaFunctionPublish(functionName, versionDescription, awsLambda, fileName, file, fileHandler); + ByteArrayOutputStream outContent = new ByteArrayOutputStream(); System.setOut(new PrintStream(outContent)); String errorMessage = "^error^ Lambda function [ FunctionName ] does not exist^r^";