polygene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From paulmer...@apache.org
Subject [43/50] zest-java git commit: ZEST-107 Introduce AbstractEntityStoreWithCacheTest in core/testsupport
Date Tue, 28 Jul 2015 12:55:40 GMT
ZEST-107 Introduce AbstractEntityStoreWithCacheTest in core/testsupport

Reuse all tests from AbstractEntityStoreTest adding a MemoryCachePool to
the assembly (overridable).


Project: http://git-wip-us.apache.org/repos/asf/zest-java/repo
Commit: http://git-wip-us.apache.org/repos/asf/zest-java/commit/4a1788b0
Tree: http://git-wip-us.apache.org/repos/asf/zest-java/tree/4a1788b0
Diff: http://git-wip-us.apache.org/repos/asf/zest-java/diff/4a1788b0

Branch: refs/heads/master
Commit: 4a1788b0706867a2c2e588bd5bc403433a386583
Parents: ef1dcd5
Author: Paul Merlin <paulmerlin@apache.org>
Authored: Mon Jul 27 16:32:09 2015 +0200
Committer: Paul Merlin <paulmerlin@apache.org>
Committed: Mon Jul 27 17:09:02 2015 +0200

----------------------------------------------------------------------
 .../cache/AbstractEntityStoreWithCacheTest.java | 165 +++++++++++++++++++
 1 file changed, 165 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/zest-java/blob/4a1788b0/core/testsupport/src/main/java/org/qi4j/test/cache/AbstractEntityStoreWithCacheTest.java
----------------------------------------------------------------------
diff --git a/core/testsupport/src/main/java/org/qi4j/test/cache/AbstractEntityStoreWithCacheTest.java
b/core/testsupport/src/main/java/org/qi4j/test/cache/AbstractEntityStoreWithCacheTest.java
new file mode 100644
index 0000000..0d3de54
--- /dev/null
+++ b/core/testsupport/src/main/java/org/qi4j/test/cache/AbstractEntityStoreWithCacheTest.java
@@ -0,0 +1,165 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.qi4j.test.cache;
+
+import org.junit.Test;
+import org.qi4j.api.common.Optional;
+import org.qi4j.api.injection.scope.Service;
+import org.qi4j.api.unitofwork.UnitOfWorkCompletionException;
+import org.qi4j.bootstrap.AssemblyException;
+import org.qi4j.bootstrap.ModuleAssembly;
+import org.qi4j.test.entity.AbstractEntityStoreTest;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Assert Cache behaviour when used by an EntityStore.
+ * <p>
+ * Use an in-memory CachePool by default, implement the <code>assembleCachePool</code>
method to override.
+ */
+public abstract class AbstractEntityStoreWithCacheTest
+    extends AbstractEntityStoreTest
+{
+    @Optional @Service MemoryCachePoolService cachePool;
+
+    @Override
+    public void assemble( ModuleAssembly module )
+        throws AssemblyException
+    {
+        super.assemble( module );
+        assembleCachePool( module );
+    }
+
+    protected void assembleCachePool( ModuleAssembly module )
+        throws AssemblyException
+    {
+        module.services( MemoryCachePoolService.class );
+    }
+
+    @Test
+    public void whenNewEntityThenCanFindEntityAndCorrectValues()
+        throws Exception
+    {
+        super.whenNewEntityThenCanFindEntityAndCorrectValues();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 1 ) );
+            assertThat( cache.puts(), is( 1 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void whenRemovedEntityThenCannotFindEntity()
+        throws Exception
+    {
+        super.whenRemovedEntityThenCannotFindEntity();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 0 ) );
+            assertThat( cache.gets(), is( 2 ) );
+            assertThat( cache.puts(), is( 1 ) );
+            assertThat( cache.removes(), is( 1 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void givenEntityIsNotModifiedWhenUnitOfWorkCompletesThenDontStoreState()
+        throws UnitOfWorkCompletionException
+    {
+        super.givenEntityIsNotModifiedWhenUnitOfWorkCompletesThenDontStoreState();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 2 ) );
+            assertThat( cache.puts(), is( 1 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void givenPropertyIsModifiedWhenUnitOfWorkCompletesThenStoreState()
+        throws UnitOfWorkCompletionException
+    {
+        super.givenPropertyIsModifiedWhenUnitOfWorkCompletesThenStoreState();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 2 ) );
+            assertThat( cache.puts(), is( 2 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void givenManyAssociationIsModifiedWhenUnitOfWorkCompletesThenStoreState()
+        throws UnitOfWorkCompletionException
+    {
+        super.givenManyAssociationIsModifiedWhenUnitOfWorkCompletesThenStoreState();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 2 ) );
+            assertThat( cache.puts(), is( 2 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void givenConcurrentUnitOfWorksWhenUoWCompletesThenCheckConcurrentModification()
+        throws UnitOfWorkCompletionException
+    {
+        super.givenConcurrentUnitOfWorksWhenUoWCompletesThenCheckConcurrentModification();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 4 ) );
+            assertThat( cache.puts(), is( 2 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+
+    @Test
+    public void givenEntityStoredLoadedChangedWhenUnitOfWorkDiscardsThenDontStoreState()
+        throws UnitOfWorkCompletionException
+    {
+        super.givenEntityStoredLoadedChangedWhenUnitOfWorkDiscardsThenDontStoreState();
+        if( cachePool != null )
+        {
+            MemoryCacheImpl<?> cache = cachePool.singleCache();
+            assertThat( cache.size(), is( 1 ) );
+            assertThat( cache.gets(), is( 2 ) );
+            assertThat( cache.puts(), is( 1 ) );
+            assertThat( cache.removes(), is( 0 ) );
+            assertThat( cache.exists(), is( 0 ) );
+        }
+    }
+}


Mime
View raw message