Skip to content

Commit

Permalink
Add unit tests.
Browse files Browse the repository at this point in the history
  • Loading branch information
@fdlk
fdlk committed Aug 17, 2016
1 parent 9c645fd commit dc05002
Show file tree
Hide file tree
Showing 2 changed files with 187 additions and 50 deletions.
128 changes: 97 additions & 31 deletions ...s-data-cache/src/test/java/org/molgenis/data/cache/l3/L3CacheRepositoryDecoratorTest.java
View file
Expand Up @@ -40,11 +40,11 @@ public class L3CacheRepositoryDecoratorTest extends AbstractMolgenisSpringTest
private L3CacheRepositoryDecorator l3CacheRepositoryDecorator;
private EntityMetaData entityMetaData;

private Entity mockEntity1;
private Entity mockEntity2;
private Entity mockEntity3;
private Entity entity1;
private Entity entity2;
private Entity entity3;

private final String repository = "TestRepository";
private final String repositoryName = "TestRepository";
private static final String COUNTRY = "Country";
private static final String ID = "ID";

Expand All @@ -69,68 +69,83 @@ public class L3CacheRepositoryDecoratorTest extends AbstractMolgenisSpringTest
@Captor
private ArgumentCaptor<Stream<Object>> entityIdCaptor;

private Query<Entity> query;

@Mock
private Fetch fetch;

@BeforeClass
public void beforeClass()
{
initMocks(this);

entityMetaData = entityMetaDataFactory.create(repository);
entityMetaData = entityMetaDataFactory.create(repositoryName);
entityMetaData.addAttribute(attributeMetaDataFactory.create().setDataType(INT).setName(ID), ROLE_ID);
entityMetaData.addAttribute(attributeMetaDataFactory.create().setName(COUNTRY));

when(entityManager.create(entityMetaData)).thenReturn(new DynamicEntity(entityMetaData));

mockEntity1 = entityManager.create(entityMetaData);
mockEntity1.set(ID, 1);
mockEntity1.set(COUNTRY, "NL");
entity1 = entityManager.create(entityMetaData);
entity1.set(ID, 1);
entity1.set(COUNTRY, "NL");

mockEntity2 = entityManager.create(entityMetaData);
mockEntity2.set(ID, 2);
mockEntity2.set(COUNTRY, "NL");
entity2 = entityManager.create(entityMetaData);
entity2.set(ID, 2);
entity2.set(COUNTRY, "NL");

mockEntity3 = entityManager.create(entityMetaData);
mockEntity3.set(ID, 3);
mockEntity3.set(COUNTRY, "GB");
entity3 = entityManager.create(entityMetaData);
entity3.set(ID, 3);
entity3.set(COUNTRY, "GB");

when(decoratedRepository.getCapabilities()).thenReturn(Sets.newHashSet(CACHEABLE));
l3CacheRepositoryDecorator = new L3CacheRepositoryDecorator(decoratedRepository, l3Cache,
transactionInformation);

query = new QueryImpl<>().eq(COUNTRY, "GB");
query.pageSize(10);
query.sort(new Sort().on(COUNTRY));
query.setFetch(fetch);
}

@BeforeMethod
public void beforeMethod()
{
reset(l3Cache, transactionInformation, decoratedRepository);
when(decoratedRepository.getEntityMetaData()).thenReturn(entityMetaData);
when(decoratedRepository.getName()).thenReturn(entityMetaData.getName());
when(decoratedRepository.getName()).thenReturn(repositoryName);
}

@Test
public void testFindOne()
public void testFindOneRepositoryClean()
{
when(transactionInformation.isRepositoryCompletelyClean(entityMetaData.getName())).thenReturn(true);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "GB");
query.pageSize(1);
query.sort(new Sort());
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(true);
Query<Entity> queryWithPageSizeOne = new QueryImpl<>(query).pageSize(1);
when(l3Cache.get(decoratedRepository, queryWithPageSizeOne)).thenReturn(singletonList(3));
when(decoratedRepository.findOneById(3, fetch)).thenReturn(entity3);

assertEquals(l3CacheRepositoryDecorator.findOne(queryWithPageSizeOne), entity3);
verify(decoratedRepository, times(1)).findOneById(3, fetch);
verify(decoratedRepository, atLeast(0)).getName();
verifyNoMoreInteractions(decoratedRepository);
}

when(l3Cache.get(decoratedRepository, query)).thenReturn(singletonList(3));
when(decoratedRepository.findOneById(3, query.getFetch())).thenReturn(mockEntity3);
@Test
public void testFindOneRepositoryDirty()
{
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(false);
when(decoratedRepository.findOne(query)).thenReturn(entity3);

Entity actualEntity = l3CacheRepositoryDecorator.findOne(query);
assertEquals(actualEntity, mockEntity3);
assertEquals(l3CacheRepositoryDecorator.findOne(query), entity3);
verifyNoMoreInteractions(l3Cache);
}

@Test
public void testFindAll()
public void testFindAllRepositoryClean()
{
when(transactionInformation.isRepositoryCompletelyClean(entityMetaData.getName())).thenReturn(true);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "NL");
query.pageSize(10);
query.sort(new Sort());
query.fetch(new Fetch());
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(true);

List<Object> ids = asList(1, 2);
List<Entity> expectedEntities = newArrayList(mockEntity1, mockEntity2);
List<Entity> expectedEntities = newArrayList(entity1, entity2);

when(l3Cache.get(decoratedRepository, query)).thenReturn(ids);
when(decoratedRepository.findAll(entityIdCaptor.capture(), eq(query.getFetch())))
Expand All @@ -142,6 +157,57 @@ public void testFindAll()
assertEquals(entityIdCaptor.getValue().collect(toList()), ids);
}

@Test
public void testFindAllVeryLargePageSize()
{
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(true);
Query<Entity> largeQuery = new QueryImpl<>(query).setPageSize(10000);

List<Entity> expectedEntities = newArrayList(entity1, entity2);

when(decoratedRepository.findAll(largeQuery)).thenReturn(expectedEntities.stream());

List<Entity> actualEntities = l3CacheRepositoryDecorator.findAll(largeQuery).collect(toList());

assertEquals(actualEntities, expectedEntities);
verifyNoMoreInteractions(l3Cache);
}

@Test
public void testFindAllZeroPageSize()
{
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(true);
Query<Entity> largeQuery = new QueryImpl<>(query).setPageSize(0);

List<Entity> expectedEntities = newArrayList(entity1, entity2);

when(decoratedRepository.findAll(largeQuery)).thenReturn(expectedEntities.stream());

List<Entity> actualEntities = l3CacheRepositoryDecorator.findAll(largeQuery).collect(toList());

assertEquals(actualEntities, expectedEntities);
verifyNoMoreInteractions(l3Cache);
}

@Test
public void testFindAllRepositoryDirty()
{
when(transactionInformation.isRepositoryCompletelyClean(repositoryName)).thenReturn(false);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "NL");
query.pageSize(10);
query.sort(new Sort());
query.fetch(new Fetch());

List<Entity> expectedEntities = newArrayList(entity1, entity2);

when(decoratedRepository.findAll(query)).thenReturn(expectedEntities.stream());

List<Entity> actualEntities = l3CacheRepositoryDecorator.findAll(query).collect(toList());

assertEquals(actualEntities, expectedEntities);
verifyNoMoreInteractions(l3Cache);
}

@Configuration
public static class Config
{
Expand Down
109 changes: 90 additions & 19 deletions molgenis-data-cache/src/test/java/org/molgenis/data/cache/l3/L3CacheTest.java
View file
@@ -1,6 +1,7 @@
package org.molgenis.data.cache.l3;

import com.google.common.collect.Sets;
import com.google.common.util.concurrent.UncheckedExecutionException;
import org.mockito.Mock;
import org.molgenis.data.*;
import org.molgenis.data.meta.model.AttributeMetaDataFactory;
Expand All @@ -12,14 +13,12 @@
import org.molgenis.data.transaction.TransactionInformation;
import org.molgenis.test.data.AbstractMolgenisSpringTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.stream.Stream;

import static org.mockito.Mockito.*;
Expand All @@ -28,8 +27,8 @@
import static org.molgenis.data.RepositoryCapability.CACHEABLE;
import static org.molgenis.data.meta.model.EntityMetaData.AttributeRole.ROLE_ID;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;

@ContextConfiguration(classes = L3CacheTest.Config.class)
public class L3CacheTest extends AbstractMolgenisSpringTest
{
private L3Cache l3Cache;
Expand Down Expand Up @@ -59,9 +58,6 @@ public class L3CacheTest extends AbstractMolgenisSpringTest
@Autowired
private AttributeMetaDataFactory attributeMetaDataFactory;

@Autowired
private EntityManager entityManager;

@BeforeClass
public void beforeClass()
{
Expand All @@ -84,21 +80,22 @@ public void beforeClass()
entity3 = new DynamicEntity(entityMetaData);
entity3.set(ID, 3);
entity3.set(COUNTRY, "GB");

when(decoratedRepository.getCapabilities()).thenReturn(Sets.newHashSet(CACHEABLE));
when(decoratedRepository.getName()).thenReturn(repositoryName);
when(decoratedRepository.getEntityMetaData()).thenReturn(entityMetaData);
l3Cache = new L3Cache(molgenisTransactionManager, transactionInformation);
}

@BeforeMethod
public void beforeMethod()
{
reset(decoratedRepository);

when(decoratedRepository.getCapabilities()).thenReturn(Sets.newHashSet(CACHEABLE));
when(decoratedRepository.getName()).thenReturn(repositoryName);
when(decoratedRepository.getEntityMetaData()).thenReturn(entityMetaData);

l3Cache = new L3Cache(molgenisTransactionManager, transactionInformation);
}

@Test
public void testGetIgnoresFetch()
public void testGet()
{
Fetch idAttributeFetch = new Fetch().field(entityMetaData.getIdAttribute().getName());
Query<Entity> fetchLessQuery = new QueryImpl<>().eq(COUNTRY, "NL").fetch(idAttributeFetch);
Expand All @@ -111,20 +108,94 @@ public void testGetIgnoresFetch()
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));

verify(decoratedRepository, atMost(1)).findAll(fetchLessQuery);
verify(decoratedRepository, times(1)).findAll(fetchLessQuery);
verify(decoratedRepository, atLeast(0)).getName();
verify(decoratedRepository, atLeast(0)).getEntityMetaData();
verifyNoMoreInteractions(decoratedRepository);
}

@Configuration
public static class Config
@Test
public void testGetThrowsException()
{
@Bean
public EntityManager entityManager()
Fetch idAttributeFetch = new Fetch().field(entityMetaData.getIdAttribute().getName());
Query<Entity> fetchLessQuery = new QueryImpl<>().eq(COUNTRY, "NL").fetch(idAttributeFetch);

when(decoratedRepository.findAll(fetchLessQuery)).thenThrow(new MolgenisDataException("What table?"));

Fetch fetch = mock(Fetch.class);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "NL").fetch(fetch);

try
{
return mock(EntityManager.class);
l3Cache.get(decoratedRepository, query);
// check that exception is thrown by the get method
fail("Get should throw exception");
}
catch (UncheckedExecutionException expected)
{

}
// Check that exception isn't cached.
try
{
l3Cache.get(decoratedRepository, query);
fail("Get should throw exception");
}
catch (UncheckedExecutionException expected)
{

}
verify(decoratedRepository, times(2)).findAll(fetchLessQuery);
}

@Test
public void testAfterCommitTransactionDirtyRepository()
{
Fetch idAttributeFetch = new Fetch().field(entityMetaData.getIdAttribute().getName());
Query<Entity> fetchLessQuery = new QueryImpl<>().eq(COUNTRY, "NL").fetch(idAttributeFetch);

when(decoratedRepository.findAll(fetchLessQuery)).thenReturn(Stream.of(entity1, entity2));

Fetch fetch = mock(Fetch.class);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "NL").fetch(fetch);

assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));

when(transactionInformation.getDirtyRepositories()).thenReturn(Collections.singleton(repositoryName));
l3Cache.afterCommitTransaction("ABCDE");

when(decoratedRepository.findAll(fetchLessQuery)).thenReturn(Stream.of(entity3, entity2));

assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(3, 2));
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(3, 2));

verify(decoratedRepository, times(2)).findAll(fetchLessQuery);
}

@Test
public void testAfterCommitTransactionCleanRepository()
{
Fetch idAttributeFetch = new Fetch().field(entityMetaData.getIdAttribute().getName());
Query<Entity> fetchLessQuery = new QueryImpl<>().eq(COUNTRY, "NL").fetch(idAttributeFetch);

when(decoratedRepository.findAll(fetchLessQuery)).thenReturn(Stream.of(entity1, entity2));

Fetch fetch = mock(Fetch.class);
Query<Entity> query = new QueryImpl<>().eq(COUNTRY, "NL").fetch(fetch);

assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));

when(transactionInformation.getDirtyRepositories()).thenReturn(Collections.singleton("blah"));
l3Cache.afterCommitTransaction("ABCDE");

assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));
assertEquals(l3Cache.get(decoratedRepository, query), Arrays.asList(1, 2));

verify(decoratedRepository, times(1)).findAll(fetchLessQuery);
verify(decoratedRepository, atLeast(0)).getName();
verify(decoratedRepository, atLeast(0)).getEntityMetaData();
verifyNoMoreInteractions(decoratedRepository);
}
}

0 comments on commit dc05002

Please sign in to comment.