Improving Unit test coverage

Author: derjust

pom.xml

@@ -39,7 +39,6 @@
     <properties>
         <spring.version>5.0.1.RELEASE</spring.version>
         <spring-data.version>Kay-SR1</spring-data.version>
-        <artifact.selectedVersion.minorVersion>0</artifact.selectedVersion.minorVersion>
 
         <hibernate-validator.version>5.2.4.Final</hibernate-validator.version>
         <aws-java-sdk.version>1.11.232</aws-java-sdk.version>

src/main/java/org/socialsignin/spring/data/dynamodb/core/DynamoDBTemplate.java

@@ -40,10 +40,12 @@
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 public class DynamoDBTemplate implements DynamoDBOperations, ApplicationContextAware {
 
@@ -109,7 +111,7 @@ public <T> int count(Class<T> domainClass,
 	public <T> PaginatedQueryList<T> query(Class<T> domainClass,
 			DynamoDBQueryExpression<T> queryExpression) {
 		PaginatedQueryList<T> results = dynamoDBMapper.query(domainClass, queryExpression);
-		maybeEmitEvent(new AfterQueryEvent<T>(results));
+		maybeEmitEvent(results, AfterQueryEvent::new);
 		return results;
 	}
 
@@ -122,28 +124,24 @@ public <T> int count(Class<T> domainClass,
 	@Override
 	public <T> T load(Class<T> domainClass, Object hashKey, Object rangeKey) {
 		T entity =  dynamoDBMapper.load(domainClass, hashKey,rangeKey);
-		if (entity != null)
-		{
-			maybeEmitEvent(new AfterLoadEvent<>(entity));
-		}
+		maybeEmitEvent(entity, AfterLoadEvent::new);
+
 		return entity;
 	}
 
 	@Override
 	public <T> T load(Class<T> domainClass, Object hashKey) {
 		T entity =  dynamoDBMapper.load(domainClass, hashKey);
-		if (entity != null)
-		{
-			maybeEmitEvent(new AfterLoadEvent<>(entity));
-		}
+		maybeEmitEvent(entity, AfterLoadEvent::new);
+
 		return entity;
 	}
 
 	@Override
 	public <T> PaginatedScanList<T> scan(Class<T> domainClass,
 			DynamoDBScanExpression scanExpression) {
 		PaginatedScanList<T> results = dynamoDBMapper.scan(domainClass, scanExpression);
-		maybeEmitEvent(new AfterScanEvent<T>(results));
+		maybeEmitEvent(results, AfterScanEvent::new);
 		return results;
 	}
 
@@ -154,45 +152,45 @@ public Map<String, List<Object>> batchLoad(Map<Class<?>, List<KeyPair>> itemsToG
 		{
 			for (Object entity : resultList)
 			{
-				maybeEmitEvent(new AfterLoadEvent<Object>(entity));
+				maybeEmitEvent(entity, AfterLoadEvent::new);
 			}
 		}
 		return results;
 	}
 
 	@Override
 	public void save(Object entity) {
-		maybeEmitEvent(new BeforeSaveEvent<>(entity));
+		maybeEmitEvent(entity, BeforeSaveEvent::new);
 		dynamoDBMapper.save(entity);
-		maybeEmitEvent(new AfterSaveEvent<>(entity));
+		maybeEmitEvent(entity, AfterSaveEvent::new);
 
 	}
 
 	@Override
 	public List<FailedBatch> batchSave(Iterable<?> entities) {
-		entities.forEach(it -> maybeEmitEvent(new BeforeSaveEvent<>(it)));
+		entities.forEach(it -> maybeEmitEvent(it, BeforeSaveEvent::new));
 
 		List<FailedBatch> result = dynamoDBMapper.batchSave(entities);
 
-		entities.forEach(it -> maybeEmitEvent(new AfterSaveEvent<>(it)));
+		entities.forEach(it -> maybeEmitEvent(it, AfterSaveEvent::new));
         return result;
     }
 
 	@Override
 	public void delete(Object entity) {
-		maybeEmitEvent(new BeforeDeleteEvent<>(entity));
+		maybeEmitEvent(entity, BeforeDeleteEvent::new);
 		dynamoDBMapper.delete(entity);
-		maybeEmitEvent(new AfterDeleteEvent<>(entity));
+		maybeEmitEvent(entity, AfterDeleteEvent::new);
 
 	}
 
 	@Override
 	public List<FailedBatch> batchDelete(Iterable<?> entities) {
-		entities.forEach(it -> maybeEmitEvent(new BeforeDeleteEvent<>(it)));
+		entities.forEach(it -> maybeEmitEvent(it, BeforeDeleteEvent::new));
 
 	    List<FailedBatch> result = dynamoDBMapper.batchDelete(entities);
 
-		entities.forEach(it -> maybeEmitEvent(new AfterDeleteEvent<>(it)));
+		entities.forEach(it -> maybeEmitEvent(it, AfterDeleteEvent::new));
 		return result;
 	}
 
@@ -243,11 +241,14 @@ public <T> DynamoDBMapperTableModel<T> getTableModel(Class<T> domainClass) {
         return dynamoDBMapper.getTableModel(domainClass, dynamoDBMapperConfig);
     }
 
-	protected <T> void maybeEmitEvent(DynamoDBMappingEvent<T> event) {
-		if (null != eventPublisher) {
-			eventPublisher.publishEvent(event);
+    protected <T> void maybeEmitEvent(@Nullable T source, Function<T, DynamoDBMappingEvent<T>> factory) {
+    	if (eventPublisher != null) {
+    		if (source != null) {
+				DynamoDBMappingEvent<T> event = factory.apply(source);
+
+				eventPublisher.publishEvent(event);
+			}
 		}
-}
 
-	
+	}
 }

src/main/java/org/socialsignin/spring/data/dynamodb/mapping/event/AbstractDynamoDBEventListener.java

@@ -82,29 +82,33 @@ public void onApplicationEvent(DynamoDBMappingEvent<?> event) {
 		if (event instanceof AfterScanEvent) {
 
 			publishEachElement((PaginatedScanList<?>)source, this::onAfterScan);
-
+			return;
 		} else if (event instanceof AfterQueryEvent) {
 
 			publishEachElement((PaginatedQueryList<?>)source, this::onAfterQuery);
+			return;
 		}
 		// Check for matching domain type and invoke callbacks
 		else if (domainClass.isAssignableFrom(source.getClass())) {
 			if (event instanceof BeforeSaveEvent) {
 				onBeforeSave(source);
+				return;
 			} else if (event instanceof AfterSaveEvent) {
 				onAfterSave(source);
+				return;
 			} else if (event instanceof BeforeDeleteEvent) {
 				onBeforeDelete(source);
+				return;
 			} else if (event instanceof AfterDeleteEvent) {
 				onAfterDelete(source);
+				return;
 			} else if (event instanceof AfterLoadEvent) {
 				onAfterLoad(source);
-			} else {
-				assert false;
+				return;
 			}
-		} else {
-			assert false;
 		}
+		// we should never end up here
+		assert false;
 	}
 
 	@SuppressWarnings("unchecked")

src/main/java/org/socialsignin/spring/data/dynamodb/repository/query/DynamoDBQueryCreator.java

@@ -23,13 +23,13 @@
 import org.springframework.data.repository.query.parser.PartTree;
 
 public class DynamoDBQueryCreator<T,ID> extends AbstractDynamoDBQueryCreator<T, ID,T> {
-
+/*
 	public DynamoDBQueryCreator(PartTree tree,
 			DynamoDBEntityInformation<T, ID> entityMetadata,
 			DynamoDBOperations dynamoDBOperations) {
 		super(tree, entityMetadata, dynamoDBOperations);
 	}
-
+*/
 	public DynamoDBQueryCreator(PartTree tree,
 			ParameterAccessor parameterAccessor,
 			DynamoDBEntityInformation<T, ID> entityMetadata,

src/main/java/org/socialsignin/spring/data/dynamodb/repository/query/DynamoDBQueryLookupStrategy.java

@@ -146,9 +146,7 @@ protected <T, ID> RepositoryQuery createDynamoDBQuery(Method method, RepositoryM
 				Class<T> entityClass, Class<ID> idClass, NamedQueries namedQueries) {
 			try {
 				return strategy.createDynamoDBQuery(method, metadata, factory, entityClass, idClass, namedQueries);
-			} catch (IllegalStateException e) {
-				return createStrategy.createDynamoDBQuery(method, metadata, factory, entityClass, idClass, namedQueries);
-			} catch (UnsupportedOperationException e) {
+			} catch (IllegalStateException | UnsupportedOperationException e) {
 				return createStrategy.createDynamoDBQuery(method, metadata, factory, entityClass, idClass, namedQueries);
 			}
 

…amodb/core/DynamoDBTemplateUnitTest.java …/dynamodb/core/DynamoDBTemplateTest.javasrc/test/java/org/socialsignin/spring/data/dynamodb/core/DynamoDBTemplateUnitTest.java renamed to src/test/java/org/socialsignin/spring/data/dynamodb/core/DynamoDBTemplateTest.java src/test/java/org/socialsignin/spring/data/dynamodb/core/DynamoDBTemplateUnitTest.java renamed to src/test/java/org/socialsignin/spring/data/dynamodb/core/DynamoDBTemplateTest.java

@@ -19,6 +19,8 @@
 import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
 import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperConfig;
 import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapperConfig.TableNameResolver;
+import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBQueryExpression;
+import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBScanExpression;
 import com.amazonaws.services.dynamodbv2.document.DynamoDB;
 
 import org.junit.Assert;
@@ -39,9 +41,12 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 @RunWith(MockitoJUnitRunner.class)
-public class DynamoDBTemplateUnitTest {
+public class DynamoDBTemplateTest {
 	@Rule
 	public ExpectedException expectedException = ExpectedException.none();
 	@Mock
@@ -85,24 +90,54 @@ public void testConstructorOptionalPreconfiguredDynamoDBMapper() {
 		assertTrue("The constructor should not fail with an assert error", true);
 	}
 
-	@SuppressWarnings("unchecked")
+	@Test
+	public void testDelete() {
+		User user = new User();
+		dynamoDBTemplate.delete(user);
+
+		verify(dynamoDBMapper).delete(user);
+	}
+
 	@Test
 	public void testBatchDelete_CallsCorrectDynamoDBMapperMethod()
 	{
 			List<User> users = new ArrayList<>();
 			dynamoDBTemplate.batchDelete(users);
-			Mockito.verify(dynamoDBMapper).batchDelete(Mockito.any(List.class));
+			verify(dynamoDBMapper).batchDelete(any(List.class));
 	}
-	
-	@SuppressWarnings("unchecked")
+
+	@Test
+	public void testSave() {
+		User user = new User();
+		dynamoDBTemplate.save(user);
+
+		verify(dynamoDBMapper).save(user);
+	}
+
 	@Test
 	public void testBatchSave_CallsCorrectDynamoDBMapperMethod()
 	{
 			List<User> users = new ArrayList<>();
 			dynamoDBTemplate.batchSave(users);
-			Mockito.verify(dynamoDBMapper).batchSave(Mockito.any(List.class));
+			verify(dynamoDBMapper).batchSave(any(List.class));
 	}
-	
+
+	@Test
+	public void testCountQuery() {
+		DynamoDBQueryExpression<User> query = mock(DynamoDBQueryExpression.class);
+		int actual = dynamoDBTemplate.count(User.class, query);
+
+		verify(dynamoDBMapper).count(User.class, query);
+	}
+
+	@Test
+	public void testCountScan() {
+		DynamoDBScanExpression scan = mock(DynamoDBScanExpression.class);
+		int actual = dynamoDBTemplate.count(User.class, scan);
+
+		verify(dynamoDBMapper).count(User.class, scan);
+	}
+
 	@Test
 	public void testGetOverriddenTableName_WhenConfigIsNull()
 	{
@@ -120,7 +155,7 @@ public void testGetOverriddenTableName()
     @Test
     public void testGetOverriddenTableName_WithTableNameResolver()
     {
-        TableNameResolver tableNameResolver = Mockito.mock(TableNameResolver.class);
+        TableNameResolver tableNameResolver = mock(TableNameResolver.class);
         Mockito.when(tableNameResolver.getTableName(Object.class, dynamoDBMapperConfig)).thenReturn(
             "someOtherTableName");
         Mockito.when(dynamoDBMapperConfig.getTableNameResolver()).thenReturn(tableNameResolver);

src/test/java/org/socialsignin/spring/data/dynamodb/repository/query/DynamoDBQueryLookupStrategyTest.java

@@ -0,0 +1,64 @@
+/**
+ * Copyright © 2013 spring-data-dynamodb (https://github.com/derjust/spring-data-dynamodb)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.socialsignin.spring.data.dynamodb.repository.query;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.socialsignin.spring.data.dynamodb.core.DynamoDBOperations;
+import org.springframework.data.repository.query.QueryLookupStrategy;
+import org.springframework.data.repository.query.QueryLookupStrategy.Key;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DynamoDBQueryLookupStrategyTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+    @Mock
+    private DynamoDBOperations dynamoDBOperations;
+
+    @Test
+    public void testCreate() {
+        QueryLookupStrategy actual;
+        actual = DynamoDBQueryLookupStrategy.create(dynamoDBOperations, Key.CREATE);
+        assertNotNull(actual);
+
+        actual = DynamoDBQueryLookupStrategy.create(dynamoDBOperations, Key.CREATE_IF_NOT_FOUND);
+        assertNotNull(actual);
+    }
+
+    @Test
+    public void testNull() {
+        QueryLookupStrategy actualNull = DynamoDBQueryLookupStrategy.create(dynamoDBOperations, null);
+        QueryLookupStrategy actualCreate = DynamoDBQueryLookupStrategy.create(dynamoDBOperations, Key.CREATE);
+
+        assertSame(actualNull.getClass(), actualCreate.getClass());
+    }
+
+    @Test
+    public void testDeclaredQuery() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Unsupported query lookup strategy USE_DECLARED_QUERY!");
+
+        DynamoDBQueryLookupStrategy.create(dynamoDBOperations, Key.USE_DECLARED_QUERY);
+    }
+
+}