Spring/spring-data-geode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove use of the Hamcrest library.

Browse Source 
Replace JUnit Assertions with AssertJ.

Resolves gh-296.
This commit is contained in:
John Blum
2021-07-22 19:41:28 -07:00
parent ddcd01910e
commit 20fb6af9a5
36 changed files with 1462 additions and 1180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
spring-data-geode/pom.xml
View File

@@ -217,20 +217,6 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-core</artifactId>
<version>${hamcrest}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
<version>${hamcrest}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.iq80.snappy</groupId>
<artifactId>snappy</artifactId>

12
spring-data-geode/src/main/java/org/springframework/data/gemfire/IndexMaintenancePolicyType.java
View File

@@ -13,14 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.RegionFactory;
/**
* The IndexMaintenanceType enum is a enumerated type of GemFire Index maintenance update options.
* The {@link IndexMaintenancePolicyType} enum is a enumerated type of GemFire Index maintenance update options.
*
* @author John Blum
* @see org.apache.geode.cache.AttributesFactory#setIndexMaintenanceSynchronous(boolean)
@@ -30,6 +29,7 @@ import org.apache.geode.cache.RegionFactory;
*/
@SuppressWarnings("unused")
public enum IndexMaintenancePolicyType {
SYNCHRONOUS,
ASYNCHRONOUS;
@@ -45,7 +45,8 @@ public enum IndexMaintenancePolicyType {
* @see java.lang.String#equalsIgnoreCase(String)
* @see #name()
*/
public static IndexMaintenancePolicyType valueOfIgnoreCase(final String name) {
public static IndexMaintenancePolicyType valueOfIgnoreCase(String name) {
for (IndexMaintenancePolicyType indexMaintenancePolicyType : values()) {
if (indexMaintenancePolicyType.name().equalsIgnoreCase(name)) {
return indexMaintenancePolicyType;
@@ -64,7 +65,7 @@ public enum IndexMaintenancePolicyType {
* @see #setIndexMaintenance(org.apache.geode.cache.RegionFactory)
*/
@SuppressWarnings("deprecation")
public void setIndexMaintenance(final AttributesFactory attributesFactory) {
public void setIndexMaintenance(AttributesFactory<?, ?> attributesFactory) {
attributesFactory.setIndexMaintenanceSynchronous(equals(SYNCHRONOUS));
}
@@ -76,8 +77,7 @@ public enum IndexMaintenancePolicyType {
* @throws java.lang.NullPointerException if the RegionFactory reference is null.
* @see #setIndexMaintenance(org.apache.geode.cache.AttributesFactory)
*/
public void setIndexMaintenance(final RegionFactory regionFactory) {
public void setIndexMaintenance(RegionFactory<?, ?> regionFactory) {
regionFactory.setIndexMaintenanceSynchronous(equals(SYNCHRONOUS));
}
}

5
spring-data-geode/src/test/java/org/springframework/data/gemfire/GemfireTemplateIntegrationTests.java
View File

@@ -16,8 +16,7 @@
package org.springframework.data.gemfire;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.Assume.assumeThat;
import static org.assertj.core.api.Assumptions.assumeThat;
import java.time.Instant;
import java.util.ArrayList;
@@ -190,7 +189,7 @@ public class GemfireTemplateIntegrationTests extends IntegrationTestsSupport {
@Test
public void containsKeyOnServer() {
assumeThat(CacheUtils.isClient(this.gemfireCache), is(true));
assumeThat(CacheUtils.isClient(this.gemfireCache)).isTrue();
assertThat(this.usersTemplate.containsKeyOnServer(getKey(getUser("jackHandy")))).isTrue();
assertThat(this.usersTemplate.containsKeyOnServer("maxPayne")).isFalse();

37
spring-data-geode/src/test/java/org/springframework/data/gemfire/GemfireUtilsTest.java → spring-data-geode/src/test/java/org/springframework/data/gemfire/GemfireUtilsUnitTests.java
View File

@@ -13,45 +13,42 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import java.util.Properties;
import org.junit.Test;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.distributed.DistributedSystem;
import org.junit.Test;
/**
* The GemfireUtilsTest class is a test suite of test cases testing the contract and functionality of the GemfireUtils
* abstract utility class.
* Unit Tests for {@link GemfireUtils}.
*
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.GemfireUtils
* @since 1.3.3
*/
public class GemfireUtilsTest {
public class GemfireUtilsUnitTests {
@Test
public void isClientWithClientIsTrue() {
ClientCache mockClient = mock(ClientCache.class);
assertThat(GemfireUtils.isClient(mockClient), is(true));
assertThat(GemfireUtils.isClient(mockClient)).isTrue();
verifyZeroInteractions(mockClient);
verifyNoInteractions(mockClient);
}
@Test
@@ -59,9 +56,9 @@ public class GemfireUtilsTest {
Cache mockCache = mock(Cache.class);
assertThat(GemfireUtils.isClient(mockCache), is(false));
assertThat(GemfireUtils.isClient(mockCache)).isFalse();
verifyZeroInteractions(mockCache);
verifyNoInteractions(mockCache);
}
@Test
@@ -79,7 +76,7 @@ public class GemfireUtilsTest {
when(mockDistributedSystem.isConnected()).thenReturn(true);
when(mockDistributedSystem.getProperties()).thenReturn(gemfireProperties);
assertThat(GemfireUtils.isDurable(mockClientCache), is(true));
assertThat(GemfireUtils.isDurable(mockClientCache)).isTrue();
verify(mockClientCache, times(1)).getDistributedSystem();
verify(mockDistributedSystem, times(1)).isConnected();
@@ -101,7 +98,7 @@ public class GemfireUtilsTest {
when(mockDistributedSystem.isConnected()).thenReturn(true);
when(mockDistributedSystem.getProperties()).thenReturn(gemfireProperties);
assertThat(GemfireUtils.isDurable(mockClientCache), is(false));
assertThat(GemfireUtils.isDurable(mockClientCache)).isFalse();
verify(mockClientCache, times(1)).getDistributedSystem();
verify(mockDistributedSystem, times(1)).isConnected();
@@ -118,7 +115,7 @@ public class GemfireUtilsTest {
when(mockClientCache.getDistributedSystem()).thenReturn(mockDistributedSystem);
when(mockDistributedSystem.isConnected()).thenReturn(false);
assertThat(GemfireUtils.isDurable(mockClientCache), is(false));
assertThat(GemfireUtils.isDurable(mockClientCache)).isFalse();
verify(mockClientCache, times(1)).getDistributedSystem();
verify(mockDistributedSystem, times(1)).isConnected();
@@ -130,9 +127,9 @@ public class GemfireUtilsTest {
Cache mockCache = mock(Cache.class);
assertThat(GemfireUtils.isPeer(mockCache), is(true));
assertThat(GemfireUtils.isPeer(mockCache)).isTrue();
verifyZeroInteractions(mockCache);
verifyNoInteractions(mockCache);
}
@Test
@@ -140,8 +137,8 @@ public class GemfireUtilsTest {
ClientCache mockClientCache = mock(ClientCache.class);
assertThat(GemfireUtils.isPeer(mockClientCache), is(false));
assertThat(GemfireUtils.isPeer(mockClientCache)).isFalse();
verifyZeroInteractions(mockClientCache);
verifyNoInteractions(mockClientCache);
}
}

46
spring-data-geode/src/test/java/org/springframework/data/gemfire/IndexMaintenancePolicyConverterUnitTests.java
View File

@@ -13,20 +13,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link IndexMaintenancePolicyConverter}.
* Unit Tests for {@link IndexMaintenancePolicyConverter}.
*
* @author John Blum
* @see org.junit.Test
@@ -36,9 +31,6 @@ import org.junit.rules.ExpectedException;
*/
public class IndexMaintenancePolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final IndexMaintenancePolicyConverter converter = new IndexMaintenancePolicyConverter();
@After
@@ -48,37 +40,53 @@ public class IndexMaintenancePolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("asynchronous")).isEqualTo(IndexMaintenancePolicyType.ASYNCHRONOUS);
assertThat(converter.convert("Synchronous")).isEqualTo(IndexMaintenancePolicyType.SYNCHRONOUS);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[sync] is not a valid IndexMaintenancePolicyType");
converter.convert("sync");
try {
converter.convert("sync");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[sync] is not a valid IndexMaintenancePolicyType");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("aSynchronous");
assertThat(converter.getValue()).isEqualTo(IndexMaintenancePolicyType.ASYNCHRONOUS);
converter.setAsText("synchrONoUS");
assertThat(converter.getValue()).isEqualTo(IndexMaintenancePolicyType.SYNCHRONOUS);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[async] is not a valid IndexMaintenancePolicyType");
try {
converter.setAsText("async");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[async] is not a valid IndexMaintenancePolicyType");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

46
spring-data-geode/src/test/java/org/springframework/data/gemfire/IndexTypeConverterUnitTests.java
View File

@@ -13,20 +13,15 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link IndexTypeConverter}.
* Unit Tests for {@link IndexTypeConverter}.
*
* @author John Blum
* @see org.junit.Test
@@ -36,9 +31,6 @@ import org.junit.rules.ExpectedException;
*/
public class IndexTypeConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final IndexTypeConverter converter = new IndexTypeConverter();
@After
@@ -48,6 +40,7 @@ public class IndexTypeConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("FUNCTIONAL")).isEqualTo(IndexType.FUNCTIONAL);
assertThat(converter.convert("hASh")).isEqualTo(IndexType.HASH);
assertThat(converter.convert("hASH")).isEqualTo(IndexType.HASH);
@@ -55,33 +48,48 @@ public class IndexTypeConverterUnitTests {
assertThat(converter.convert("primary_KEY")).isEqualTo(IndexType.PRIMARY_KEY);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertWithIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[function] is not a valid IndexType");
converter.convert("function");
try {
converter.convert("function");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[function] is not a valid IndexType");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("HasH");
assertThat(converter.getValue()).isEqualTo(IndexType.HASH);
converter.setAsText("key");
assertThat(converter.getValue()).isEqualTo(IndexType.KEY);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[invalid] is not a valid IndexType");
try {
converter.setAsText("invalid");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[invalid] is not a valid IndexType");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

56
spring-data-geode/src/test/java/org/springframework/data/gemfire/InterestPolicyConverterUnitTests.java
View File

@@ -13,35 +13,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.InterestPolicy;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link InterestPolicyConverter}.
* Unit Tests for {@link InterestPolicyConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.InterestPolicyConverter
* @see org.apache.geode.cache.InterestPolicy
* @see org.springframework.data.gemfire.InterestPolicyConverter
* @since 1.6.0
*/
public class InterestPolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private InterestPolicyConverter converter = new InterestPolicyConverter();
private final InterestPolicyConverter converter = new InterestPolicyConverter();
@After
public void tearDown() {
@@ -50,39 +42,55 @@ public class InterestPolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("all")).isEqualTo(InterestPolicy.ALL);
assertThat(converter.convert("Cache_Content")).isEqualTo(InterestPolicy.CACHE_CONTENT);
assertThat(converter.convert("CACHE_ConTent")).isEqualTo(InterestPolicy.CACHE_CONTENT);
assertThat(converter.convert("ALL")).isEqualTo(InterestPolicy.ALL);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[invalid_value] is not a valid InterestPolicy");
converter.convert("invalid_value");
try {
converter.convert("invalid_value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[invalid_value] is not a valid InterestPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("aLl");
assertThat(converter.getValue()).isEqualTo(InterestPolicy.ALL);
converter.setAsText("Cache_CoNTeNT");
assertThat(converter.getValue()).isEqualTo(InterestPolicy.CACHE_CONTENT);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithInvalidValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[none] is not a valid InterestPolicy");
try {
converter.setAsText("none");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[none] is not a valid InterestPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

52
spring-data-geode/src/test/java/org/springframework/data/gemfire/ScopeConverterUnitTests.java
View File

@@ -13,22 +13,17 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.Scope;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link ScopeConverter}.
* Unit Tests for {@link ScopeConverter}.
*
* @author John Blum
* @see org.junit.Test
@@ -38,9 +33,6 @@ import org.junit.rules.ExpectedException;
*/
public class ScopeConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final ScopeConverter converter = new ScopeConverter();
@After
@@ -50,39 +42,55 @@ public class ScopeConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("distributed-ACK")).isEqualTo(Scope.DISTRIBUTED_ACK);
assertThat(converter.convert(" Distributed_NO-aCK")).isEqualTo(Scope.DISTRIBUTED_NO_ACK);
assertThat(converter.convert("loCAL ")).isEqualTo(Scope.LOCAL);
assertThat(converter.convert(" GLOBal ")).isEqualTo(Scope.GLOBAL);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[illegal-value] is not a valid Scope");
converter.convert("illegal-value");
try {
converter.convert("illegal-value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[illegal-value] is not a valid Scope");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("DisTributeD-nO_Ack");
assertThat(converter.getValue()).isEqualTo(Scope.DISTRIBUTED_NO_ACK);
converter.setAsText("distributed-ack");
assertThat(converter.getValue()).isEqualTo(Scope.DISTRIBUTED_ACK);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[d!5tr!but3d-n0_@ck] is not a valid Scope");
try {
converter.setAsText("d!5tr!but3d-n0_@ck");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[d!5tr!but3d-n0_@ck] is not a valid Scope");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

133
spring-data-geode/src/test/java/org/springframework/data/gemfire/cache/CallableCacheLoaderAdapterTest.java vendored
View File

@@ -14,15 +14,9 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.cache;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isA;
@@ -30,12 +24,9 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
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.invocation.InvocationOnMock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
@@ -44,14 +35,11 @@ import org.apache.geode.cache.LoaderHelper;
import org.apache.geode.cache.Region;
/**
* Unit tests to test the adaption of the {@link java.util.concurrent.Callable}
* into GemFire's {@link org.apache.geode.cache.CacheLoader} interface.
* Unit Tests to test the adaption of the {@link java.util.concurrent.Callable}
* into Apache Geode's {@link org.apache.geode.cache.CacheLoader} interface.
*
* @author John Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.junit.rules.ExpectedException
* @see org.junit.runner.RunWith
* @see org.mockito.Mock
* @see org.mockito.Mockito
* @see org.mockito.junit.MockitoJUnitRunner
@@ -67,9 +55,6 @@ public class CallableCacheLoaderAdapterTest {
@Mock
private CacheLoader<String, Object> mockCacheLoader;
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private LoaderHelper<String, Object> mockLoaderHelper;
@@ -79,115 +64,139 @@ public class CallableCacheLoaderAdapterTest {
@Test
public void constructCallableCacheLoaderAdapterWithArgumentKeyAndRegion() {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader, "key", mockRegion, "test");
assertThat(instance, is(notNullValue()));
assertThat(instance.getCacheLoader(), is(sameInstance(mockCacheLoader)));
assertThat(instance.getKey(), is(equalTo("key")));
assertThat(instance.getRegion(), is(sameInstance(mockRegion)));
assertThat(String.valueOf(instance.getArgument()), is(equalTo("test")));
assertThat(instance).isNotNull();
assertThat(instance.getCacheLoader()).isSameAs(mockCacheLoader);
assertThat(instance.getKey()).isEqualTo("key");
assertThat(instance.getRegion()).isSameAs(mockRegion);
assertThat(String.valueOf(instance.getArgument())).isEqualTo("test");
}
@Test
public void constructCallableCacheLoaderAdapterWithKeyRegionAndNoArgument() {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader, "key", mockRegion);
assertThat(instance, is(notNullValue()));
assertThat(instance.getCacheLoader(), is(sameInstance(mockCacheLoader)));
assertThat(instance.getKey(), is(equalTo("key")));
assertThat(instance.getRegion(), is(sameInstance(mockRegion)));
assertThat(instance.getArgument(), is(nullValue()));
assertThat(instance).isNotNull();
assertThat(instance.getCacheLoader()).isSameAs(mockCacheLoader);
assertThat(instance.getKey()).isEqualTo("key");
assertThat(instance.getRegion()).isSameAs(mockRegion);
assertThat(instance.getArgument()).isNull();
}
@Test
public void constructCallableCacheLoaderAdapterWithNoArgumentKeyOrRegion() {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader);
assertThat(instance, is(notNullValue()));
assertThat(instance.getCacheLoader(), is(sameInstance(mockCacheLoader)));
assertThat(instance.getKey(), is(nullValue()));
assertThat(instance.getRegion(), is(nullValue()));
assertThat(instance.getArgument(), is(nullValue()));
assertThat(instance).isNotNull();
assertThat(instance.getCacheLoader()).isSameAs(mockCacheLoader);
assertThat(instance.getKey()).isNull();
assertThat(instance.getRegion()).isNull();
assertThat(instance.getArgument()).isNull();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void constructCallableCacheLoaderAdapterWithNullCacheLoader() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("CacheLoader must not be null");
new CallableCacheLoaderAdapter<>(null);
try {
new CallableCacheLoaderAdapter<>(null);
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("CacheLoader must not be null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@SuppressWarnings("unchecked")
public void callDelegatesToLoad() throws Exception {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader, "key", mockRegion, "test");
when(mockCacheLoader.load(any(LoaderHelper.class))).thenAnswer(new Answer<String>() {
public String answer(final InvocationOnMock invocation) throws Throwable {
LoaderHelper<String, Object> loaderHelper = invocation.getArgument(0);
when(mockCacheLoader.load(any(LoaderHelper.class))).thenAnswer((Answer<String>) invocation -> {
assertThat(loaderHelper, is(notNullValue()));
assertThat(loaderHelper.getArgument(), is(equalTo("test")));
assertThat(loaderHelper.getKey(), is(equalTo("key")));
assertThat(loaderHelper.getRegion(), is(sameInstance(mockRegion)));
LoaderHelper<String, Object> loaderHelper = invocation.getArgument(0);
return "mockValue";
}
assertThat(loaderHelper).isNotNull();
assertThat(loaderHelper.getArgument()).isEqualTo("test");
assertThat(loaderHelper.getKey()).isEqualTo("key");
assertThat(loaderHelper.getRegion()).isSameAs(mockRegion);
return "mockValue";
});
assertThat(instance.call(), is(equalTo("mockValue")));
assertThat(instance.call()).isEqualTo("mockValue");
verify(mockCacheLoader, times(1)).load(isA(LoaderHelper.class));
}
@Test
@Test(expected = IllegalStateException.class)
public void callThrowsIllegalStateExceptionForNullKey() throws Exception {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader, null, mockRegion);
assertThat(instance.getKey(), is(nullValue()));
assertThat(instance.getRegion(), is(sameInstance(mockRegion)));
assertThat(instance.getKey()).isNull();
assertThat(instance.getRegion()).isSameAs(mockRegion);
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("The key for which the value is loaded for cannot be null");
try {
instance.call();
}
catch (IllegalStateException expected) {
instance.call();
assertThat(expected).hasMessage("The key for which the value is loaded for cannot be null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void callThrowsIllegalStateExceptionForNullRegion() throws Exception {
CallableCacheLoaderAdapter<String, Object> instance =
new CallableCacheLoaderAdapter<>(mockCacheLoader, "key", null);
assertThat(instance.getKey(), is(equalTo("key")));
assertThat(instance.getRegion(), is(nullValue()));
assertThat(instance.getKey()).isEqualTo("key");
assertThat(instance.getRegion()).isNull();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("The Region to load cannot be null");
try {
instance.call();
}
catch (IllegalStateException expected) {
instance.call();
assertThat(expected).hasMessage("The Region to load cannot be null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void closeDelegatesToCacheLoaderClose() {
new CallableCacheLoaderAdapter<>(mockCacheLoader).close();
verify(mockCacheLoader, times(1)).close();
}
@Test
public void loadDelegatesToCacheLoaderLoad() {
CallableCacheLoaderAdapter<String, Object> instance = new CallableCacheLoaderAdapter<>(mockCacheLoader);
when(mockCacheLoader.load(eq(mockLoaderHelper))).thenReturn("test");
assertThat(instance.load(mockLoaderHelper), is(equalTo("test")));
assertThat(instance.load(mockLoaderHelper)).isEqualTo("test");
verify(mockCacheLoader, times(1)).load(eq(mockLoaderHelper));
}

112
spring-data-geode/src/test/java/org/springframework/data/gemfire/cache/GemfireCacheManagerUnitTests.java vendored
View File

@@ -14,13 +14,9 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.cache;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
@@ -35,9 +31,7 @@ import java.util.HashSet;
import java.util.Set;
import org.junit.Before;
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;
@@ -59,36 +53,40 @@ import org.springframework.cache.Cache;
@RunWith(MockitoJUnitRunner.class)
public class GemfireCacheManagerUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private GemFireCache mockGemFireCache;
private GemfireCacheManager cacheManager;
@Mock
private Region mockRegion;
private Region<Object, Object> mockRegion;
@Before
public void setup() {
cacheManager = new GemfireCacheManager();
}
protected <T> Set<T> asSet(T... elements) {
Set<T> set = new HashSet<T>(elements.length);
@SafeVarargs
private static <T> Set<T> asSet(T... elements) {
Set<T> set = new HashSet<>(elements.length);
Collections.addAll(set, elements);
return set;
}
@SuppressWarnings("unchecked")
protected Region<?, ?> mockRegion(String name) {
private Region<?, ?> mockRegion(String name) {
Region<?, ?> mockRegion = mock(Region.class, name);
when(mockRegion.getName()).thenReturn(name);
return mockRegion;
}
protected Region<?, ?> regionFor(Iterable<Region<?, ?>> regions, String name) {
private Region<?, ?> regionFor(Iterable<Region<?, ?>> regions, String name) {
for (Region<?, ?> region : regions) {
if (region.getName().equals(name)) {
return region;
@@ -100,33 +98,46 @@ public class GemfireCacheManagerUnitTests {
@Test
public void assertGemFireCacheAvailableWithAvailableGemFireCacheIsSuccessful() {
when(mockGemFireCache.isClosed()).thenReturn(false);
assertThat(cacheManager.assertGemFireCacheAvailable(mockGemFireCache)).isSameAs(mockGemFireCache);
verify(mockGemFireCache, times(1)).isClosed();
verify(mockGemFireCache, times(1)).getName();
}
@Test
@Test(expected = IllegalStateException.class)
public void assertGemFireCacheAvailableWithNullThrowsIllegalStateException() {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(is(equalTo("A GemFire cache instance is required")));
cacheManager.assertGemFireCacheAvailable(null);
try {
cacheManager.assertGemFireCacheAvailable(null);
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("A GemFire cache instance is required");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@Test(expected = IllegalStateException.class)
public void assertGemFireCacheAvailableWithNamedClosedGemFireCacheThrowsIllegalStateException() {
when(mockGemFireCache.isClosed()).thenReturn(true);
when(mockGemFireCache.getName()).thenReturn("Example");
try {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(is(equalTo("GemFire cache [Example] has been closed")));
cacheManager.assertGemFireCacheAvailable(mockGemFireCache);
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("GemFire cache [Example] has been closed");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
verify(mockGemFireCache,times(1)).isClosed();
verify(mockGemFireCache, times(1)).getName();
@@ -135,39 +146,52 @@ public class GemfireCacheManagerUnitTests {
@Test
public void assertGemFireRegionAvailableWithAvailableGemFireRegionIsSuccessful() {
when(mockRegion.isDestroyed()).thenReturn(false);
assertThat(cacheManager.assertGemFireRegionAvailable(mockRegion, "Example")).isSameAs(mockRegion);
verify(mockRegion, times(1)).isDestroyed();
}
@Test
@Test(expected = IllegalStateException.class)
public void assertGemFireRegionAvailableWithNullThrowIllegalStateException() {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(is(equalTo("No Region for cache name [Example] was found")));
cacheManager.assertGemFireRegionAvailable(null, "Example");
try {
cacheManager.assertGemFireRegionAvailable(null, "Example");
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("No Region for cache name [Example] was found");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void assertGemFireRegionAvailableWithDestroyedGemFireRegionThrowIllegalStateException() {
when(mockRegion.isDestroyed()).thenReturn(true);
try {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(is(equalTo("Region [Example] has been destroyed")));
cacheManager.assertGemFireRegionAvailable(mockRegion, "Example");
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("Region [Example] has been destroyed");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
verify(mockRegion, times(1)).isDestroyed();
}
}
@Test
@SuppressWarnings("unchecked")
public void loadCachesIsSuccessful() {
Set<Region<?, ?>> regions = asSet(mockRegion("one"), mockRegion("two"), mockRegion("three"));
cacheManager.setRegions(regions);
@@ -185,6 +209,7 @@ public class GemfireCacheManagerUnitTests {
@Test
public void resolveRegionsReturnsGivenRegions() {
Set<Region<?, ?>> regions = asSet(mockRegion("one"), mockRegion("two"));
assertThat(cacheManager.resolveRegions(mockGemFireCache, regions, asSet("three", "four"))).isSameAs(regions);
@@ -195,8 +220,9 @@ public class GemfireCacheManagerUnitTests {
}
@Test
@SuppressWarnings("unchecked")
@SuppressWarnings({ "rawtypes", "unchecked" })
public void resolveRegionsReturnsRegionsForCacheNamesOnly() {
Region mockRegionOne = mockRegion("one");
Region mockRegionTwo = mockRegion("two");
@@ -207,7 +233,7 @@ public class GemfireCacheManagerUnitTests {
assertThat(regions).isNotNull();
assertThat(regions.size()).isEqualTo(2);
assertThat(regions).containsAll(this.<Region<?, ?>>asSet(mockRegionOne, mockRegionTwo));
assertThat(regions).containsAll(GemfireCacheManagerUnitTests.<Region<?, ?>>asSet(mockRegionOne, mockRegionTwo));
assertThat(cacheManager.isDynamic()).isFalse();
verify(mockGemFireCache, times(1)).getRegion(eq("one"));
@@ -217,6 +243,7 @@ public class GemfireCacheManagerUnitTests {
@Test
public void resolveRegionsReturnsGemFireCacheRootRegions() {
Set<Region<?, ?>> rootRegions = asSet(mockRegion("one"), mockRegion("two"));
when(mockGemFireCache.rootRegions()).thenReturn(rootRegions);
@@ -244,8 +271,8 @@ public class GemfireCacheManagerUnitTests {
}
@Test
@SuppressWarnings("unchecked")
public void regionForCacheNameReturnsRegion() {
when(mockGemFireCache.isClosed()).thenReturn(false);
when(mockGemFireCache.getName()).thenReturn("regionForCacheNameReturnsRegion");
when(mockGemFireCache.getRegion(eq("Example"))).thenReturn(mockRegion);
@@ -260,8 +287,9 @@ public class GemfireCacheManagerUnitTests {
}
@Test
@SuppressWarnings("unchecked")
@SuppressWarnings({ "rawtypes", "unchecked" })
public void getMissingCacheReturnsMissingCache() {
Region mockRegion = mockRegion("missing");
when(mockGemFireCache.getRegion(eq("missing"))).thenReturn(mockRegion);
@@ -278,7 +306,8 @@ public class GemfireCacheManagerUnitTests {
@Test
public void getMissingCacheReturnsNull() {
cacheManager.setRegions(Collections.<Region<?, ?>>singleton(mockRegion("one")));
cacheManager.setRegions(Collections.singleton(mockRegion("one")));
cacheManager.afterPropertiesSet();
assertThat(cacheManager.isDynamic()).isFalse();
@@ -287,6 +316,7 @@ public class GemfireCacheManagerUnitTests {
@Test
public void setAndGetCache() {
assertThat(cacheManager.getCache()).isNull();
cacheManager.setCache(mockGemFireCache);
@@ -300,6 +330,7 @@ public class GemfireCacheManagerUnitTests {
@Test
public void setAndGetCacheNames() {
Set<Region<?, ?>> regions = asSet(mockRegion("one"), mockRegion("two"));
cacheManager.setRegions(regions);
@@ -310,6 +341,7 @@ public class GemfireCacheManagerUnitTests {
@Test
public void setAndGetRegions() {
Set<Region<?, ?>> regions = asSet(mockRegion("one"), mockRegion("two"));
assertThat(cacheManager.getRegions()).isNull();

119
spring-data-geode/src/test/java/org/springframework/data/gemfire/cache/GemfireCacheUnitTests.java vendored
View File

@@ -14,28 +14,21 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.cache;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.isA;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.assertj.core.internal.bytebuddy.matcher.ElementMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import java.util.concurrent.Callable;
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;
@@ -45,22 +38,20 @@ import org.apache.geode.cache.Region;
import org.springframework.cache.Cache;
/**
* Unit tests for {@link GemfireCache}.
* Unit Tests for {@link GemfireCache}.
*
* @author John Blum
* @see org.junit.Test
* @see org.mockito.Mock
* @see org.mockito.junit.MockitoJUnitRunner
* @see GemfireCache
* @see org.apache.geode.cache.Region
* @see org.springframework.data.gemfire.cache.GemfireCache
* @since 1.9.0
*/
@RunWith(MockitoJUnitRunner.class)
@SuppressWarnings("rawtypes")
public class GemfireCacheUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private Callable mockCallable;
@@ -68,44 +59,60 @@ public class GemfireCacheUnitTests {
private Region mockRegion;
@Test
@SuppressWarnings("unchecked")
public void wrapIsSuccessful() {
GemfireCache gemfireCache = GemfireCache.wrap(mockRegion);
assertThat(gemfireCache).isNotNull();
assertThat(gemfireCache.getNativeCache()).isEqualTo(mockRegion);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void constructGemfireCacheWithNullRegion() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(is(equalTo("GemFire Region must not be null")));
new GemfireCache(null);
try {
new GemfireCache(null);
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("GemFire Region must not be null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void getNameReturnsRegionName() {
when(mockRegion.getName()).thenReturn("Example");
assertThat(GemfireCache.wrap(mockRegion).getName()).isEqualTo("Example");
verify(mockRegion, times(1)).getName();
}
@Test
public void clearCallsRegionClear() {
GemfireCache.wrap(mockRegion).clear();
verify(mockRegion, times(1)).clear();
}
@Test
public void evictCallsRegionRemoveWithKey() {
GemfireCache.wrap(mockRegion).evict("key");
verify(mockRegion, never()).destroy(anyObject());
verify(mockRegion, never()).destroy(any());
verify(mockRegion, times(1)).remove(eq("key"));
}
@Test
public void getReturnsValueWrapperForKey() {
when(mockRegion.get(eq("key"))).thenReturn("test");
Cache.ValueWrapper value = GemfireCache.wrap(mockRegion).get("key");
@@ -118,13 +125,17 @@ public class GemfireCacheUnitTests {
@Test
public void getReturnsNullForKey() {
when(mockRegion.get(anyString())).thenReturn(null);
assertThat(GemfireCache.wrap(mockRegion).get("key")).isNull();
verify(mockRegion, times(1)).get(eq("key"));
}
@Test
public void getReturnsValueForKeyAsDesiredType() {
when(mockRegion.get(eq("key"))).thenReturn(1);
Object value = GemfireCache.wrap(mockRegion).get("key", Integer.class);
@@ -138,71 +149,99 @@ public class GemfireCacheUnitTests {
@Test
public void getReturnsNullForKeyAsDesiredType() {
when(mockRegion.get(eq("key"))).thenReturn(null);
assertThat(GemfireCache.wrap(mockRegion).get("key", Double.class)).isNull();
verify(mockRegion, times(1)).get(eq("key"));
}
@Test
public void getReturnsValueForKeyWithNullDesiredType() {
when(mockRegion.get(eq("key"))).thenReturn(true);
assertThat(GemfireCache.wrap(mockRegion).get("key", (Class<Boolean>) null)).isTrue();
verify(mockRegion, times(1)).get(eq("key"));
}
@Test
@Test(expected = IllegalStateException.class)
public void getThrowsIllegalStateExceptionForKeyWhenValueIsNotAnInstanceOfDesiredType() {
when(mockRegion.get(eq("key"))).thenReturn(1);
try {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(String.format("Cached value [1] is not an instance of type [%s]",
Boolean.class.getName()));
GemfireCache.wrap(mockRegion).get("key", Boolean.class);
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("Cached value [1] is not an instance of type [%s]",
Boolean.class.getName());
assertThat(expected).hasNoCause();
throw expected;
}
finally {
verify(mockRegion, times(1)).get(eq("key"));
}
}
@Test
@SuppressWarnings("unchecked")
public void getReturnsValueFromCacheForKeyWithValueLoader() {
when(mockRegion.get(eq("key"))).thenReturn("test");
assertThat(GemfireCache.wrap(mockRegion).get("key", mockCallable)).isEqualTo("test");
verify(mockRegion, times(1)).get(eq("key"));
verifyZeroInteractions(mockCallable);
verifyNoInteractions(mockCallable);
}
@Test
@SuppressWarnings("unchecked")
public void getReturnsValueFromCacheForKeyAfterSynchronizationWithValueLoader() {
when(mockRegion.get(eq("key"))).thenReturn(null).thenReturn("test");
assertThat(GemfireCache.wrap(mockRegion).get("key", mockCallable)).isEqualTo("test");
verify(mockRegion, times(2)).get(eq("key"));
verifyZeroInteractions(mockCallable);
verifyNoInteractions(mockCallable);
}
@Test
@SuppressWarnings("unchecked")
public void getReturnsValueFromValueLoaderForKeyWithValueLoader() throws Exception {
when(mockRegion.get(anyString())).thenReturn(null);
when(mockCallable.call()).thenReturn("mockValue");
assertThat(GemfireCache.wrap(mockRegion).get("key", mockCallable)).isEqualTo("mockValue");
verify(mockRegion, times(2)).get(eq("key"));
verify(mockCallable, times(1)).call();
}
@Test
@SuppressWarnings("unchecked")
@Test(expected = Cache.ValueRetrievalException.class)
public void getThrowsValueRetrievalExceptionForKeyWithValueLoader() throws Exception {
when(mockRegion.get(anyString())).thenReturn(null);
when(mockCallable.call()).thenThrow(new IllegalStateException("test"));
try {
exception.expect(Cache.ValueRetrievalException.class);
exception.expectCause(isA(IllegalStateException.class));
GemfireCache.wrap(mockRegion).get("key", mockCallable);
}
catch (Cache.ValueRetrievalException expected) {
assertThat(expected).hasCauseInstanceOf(IllegalStateException.class);
throw expected;
}
finally {
verify(mockRegion, times(2)).get(eq("key"));
verify(mockCallable, times(1)).call();
@@ -212,21 +251,26 @@ public class GemfireCacheUnitTests {
@Test
@SuppressWarnings("unchecked")
public void putCachesValue() {
GemfireCache.wrap(mockRegion).put("key", "test");
verify(mockRegion, times(1)).put(eq("key"), eq("test"));
}
@Test
@SuppressWarnings("unchecked")
public void putDoesNotCacheNull() {
GemfireCache.wrap(mockRegion).put("key", null);
verify(mockRegion, never()).put(anyString(), anyObject());
verify(mockRegion, never()).put(anyString(), any());
}
@Test
@SuppressWarnings("unchecked")
public void putIfAbsentReturnsExistingValue() {
when(mockRegion.putIfAbsent(eq("key"), anyObject())).thenReturn("test");
when(mockRegion.putIfAbsent(eq("key"), any())).thenReturn("test");
Cache.ValueWrapper value = GemfireCache.wrap(mockRegion).putIfAbsent("key", "mockValue");
@@ -239,7 +283,8 @@ public class GemfireCacheUnitTests {
@Test
@SuppressWarnings("unchecked")
public void putIfAbsentReturnsNull() {
when(mockRegion.putIfAbsent(eq("key"), anyObject())).thenReturn(null);
when(mockRegion.putIfAbsent(eq("key"), any())).thenReturn(null);
Cache.ValueWrapper value = GemfireCache.wrap(mockRegion).putIfAbsent("key", "mockValue");

48
spring-data-geode/src/test/java/org/springframework/data/gemfire/client/InterestResultPolicyConverterUnitTests.java
View File

@@ -13,35 +13,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.client;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.apache.geode.cache.InterestResultPolicy;
/**
* Unit tests for {@link InterestResultPolicyConverter}.
* Unit Tests for {@link InterestResultPolicyConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see org.apache.geode.cache.InterestResultPolicy
* @see org.springframework.data.gemfire.client.InterestResultPolicyConverter
* @see org.springframework.data.gemfire.client.InterestResultPolicyType
* @see org.apache.geode.cache.InterestResultPolicy
* @since 1.6.0
*/
public class InterestResultPolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final InterestResultPolicyConverter converter = new InterestResultPolicyConverter();
@After
@@ -51,38 +43,54 @@ public class InterestResultPolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("NONE")).isEqualTo(InterestResultPolicy.NONE);
assertThat(converter.convert("kEyS_ValUes")).isEqualTo(InterestResultPolicy.KEYS_VALUES);
assertThat(converter.convert("nONe")).isEqualTo(InterestResultPolicy.NONE);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[illegal_value] is not a valid InterestResultPolicy");
converter.convert("illegal_value");
try {
converter.convert("illegal_value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[illegal_value] is not a valid InterestResultPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("NOne");
assertThat(converter.getValue()).isEqualTo(InterestResultPolicy.NONE);
converter.setAsText("KeYs");
assertThat(converter.getValue()).isEqualTo(InterestResultPolicy.KEYS);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[illegal_value] is not a valid InterestResultPolicy");
try {
converter.setAsText("illegal_value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[illegal_value] is not a valid InterestResultPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

51
spring-data-geode/src/test/java/org/springframework/data/gemfire/client/InterestUnitTests.java
View File

@@ -13,27 +13,22 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.client;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.springframework.data.gemfire.client.Interest.Type.KEY;
import static org.springframework.data.gemfire.client.Interest.Type.REGEX;
import static org.springframework.data.gemfire.client.Interest.newInterest;
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.apache.geode.cache.InterestResultPolicy;
/**
* Unit tests for {@link Interest}.
* Unit Tests for {@link Interest}.
*
* @author John Blum
* @author Mark Paluch
@@ -47,11 +42,9 @@ public class InterestUnitTests {
protected static final boolean DURABLE = true;
protected static final boolean DO_NOT_RECEIVE_VALUES = false;
@Rule
public ExpectedException exception = ExpectedException.none();
@Test
public void constructInterestWithKey() {
Interest<String> interest = new Interest<>("testKey");
assertThat(interest.getKey()).isEqualTo("testKey");
@@ -69,6 +62,7 @@ public class InterestUnitTests {
@Test
public void constructInterestWithKeyAndPolicy() {
Interest<String> interest = new Interest<>("mockKey", InterestResultPolicy.KEYS);
assertThat(interest.getKey()).isEqualTo("mockKey");
@@ -86,6 +80,7 @@ public class InterestUnitTests {
@Test
public void constructInterestWithKeyPolicyAndDurability() {
Interest<String> interest = new Interest<>(".*Key", InterestResultPolicy.NONE, DURABLE);
assertThat(interest.getKey()).isEqualTo(".*Key");
@@ -103,6 +98,7 @@ public class InterestUnitTests {
@Test
public void constructInterestWithKeyPolicyDurabilityAndReceiveValues() {
List<String> keys = asList("KeyOne", "KeyTwo", "KeyThree");
Interest<Object> interest = new Interest<>(keys, InterestResultPolicy.KEYS_VALUES,
@@ -121,17 +117,24 @@ public class InterestUnitTests {
assertThat(interest.toString()).isEqualTo(expectedString);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void constructInterestWithNullKey() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Key is required");
new Interest<>(null);
try {
new Interest<>(null);
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("Key is required");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void isAlphanumericWhitespace() {
Interest<?> interest = newInterest("key");
assertThat(interest.isAlphaNumericWhitespace('a')).isTrue();
@@ -147,6 +150,7 @@ public class InterestUnitTests {
@Test
public void isNonAlphanumericWhitespace() {
Interest<?> interest = newInterest("key");
assertThat(interest.isNotAlphaNumericWhitespace('@')).isTrue();
@@ -163,6 +167,7 @@ public class InterestUnitTests {
@Test
public void containsNonAlphanumericWhitespace() {
Interest<?> interest = newInterest("key");
assertThat(interest.containsNonAlphaNumericWhitespace(".*")).isTrue();
@@ -175,6 +180,7 @@ public class InterestUnitTests {
@Test
public void containsOnlyAlphanumericWhitespace() {
Interest<?> interest = newInterest("key");
assertThat(interest.containsNonAlphaNumericWhitespace("0")).isFalse();
@@ -190,6 +196,7 @@ public class InterestUnitTests {
@Test
public void isRegularExpression() {
Interest<?> interest = newInterest("key");
assertThat(interest.isRegularExpression(".?")).isTrue();
@@ -209,6 +216,7 @@ public class InterestUnitTests {
@Test
public void isNotRegularExpression() {
Interest<?> interest = newInterest("key");
assertThat(interest.isRegularExpression("abc")).isFalse();
@@ -222,6 +230,7 @@ public class InterestUnitTests {
@Test
public void resolveTypeIsCorrect() {
assertThat(newInterest(".*").resolveType(KEY)).isEqualTo(KEY);
assertThat(newInterest("key").resolveType(REGEX)).isEqualTo(REGEX);
assertThat(newInterest("key").resolveType(null)).isEqualTo(KEY);
@@ -232,6 +241,7 @@ public class InterestUnitTests {
@Test
@SuppressWarnings("unchecked")
public void setAndGetStateIsCorrect() {
Interest<String> interest = newInterest("key");
assertThat(interest.isDurable()).isFalse();
@@ -255,6 +265,7 @@ public class InterestUnitTests {
@Test
public void setAndGetPolicy() {
Interest<?> interest = newInterest("key");
assertThat(interest.getPolicy()).isEqualTo(InterestResultPolicy.DEFAULT);
@@ -275,6 +286,7 @@ public class InterestUnitTests {
@Test
public void isKeyTypeIsCorrect() {
Interest<?> interest = newInterest("key");
assertThat(interest.getType()).isEqualTo(KEY);
@@ -293,6 +305,7 @@ public class InterestUnitTests {
@Test
public void isRegexTypeIsCorrect() {
Interest<?> interest = newInterest("key");
assertThat(interest.getType()).isEqualTo(KEY);
@@ -311,7 +324,10 @@ public class InterestUnitTests {
@Test
public void newInterestWithBuilder() {
Interest<?> interest = newInterest(".*").makeDurable().receivesValues(false)
Interest<?> interest = newInterest(".*")
.makeDurable()
.receivesValues(false)
.usingPolicy(InterestResultPolicy.KEYS);
assertThat(interest).isNotNull();
@@ -325,7 +341,10 @@ public class InterestUnitTests {
@Test
@SuppressWarnings("unchecked")
public void newInterestWithBuilderHonorsType() {
Interest<?> interest = newInterest(".*").asType(KEY).withKey("^.+Key\\p{Digit}$")
Interest<?> interest = newInterest(".*")
.asType(KEY)
.withKey("^.+Key\\p{Digit}$")
.usingPolicy(InterestResultPolicy.NONE);
assertThat(interest).isNotNull();

84
spring-data-geode/src/test/java/org/springframework/data/gemfire/config/support/AutoRegionLookupBeanPostProcessorUnitTests.java
View File

@@ -14,22 +14,19 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.config.support;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import java.util.Collections;
@@ -37,9 +34,7 @@ import java.util.HashSet;
import java.util.Set;
import org.junit.Before;
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;
@@ -52,7 +47,7 @@ import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.data.gemfire.util.CollectionUtils;
/**
* Unit tests for {@link AutoRegionLookupBeanPostProcessor}.
* Unit Tests for {@link AutoRegionLookupBeanPostProcessor}.
*
* @author John Blum
* @see org.junit.Test
@@ -65,9 +60,6 @@ import org.springframework.data.gemfire.util.CollectionUtils;
@RunWith(MockitoJUnitRunner.class)
public class AutoRegionLookupBeanPostProcessorUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private AutoRegionLookupBeanPostProcessor autoRegionLookupBeanPostProcessor;
@Mock
@@ -101,39 +93,55 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
assertThat(autoRegionLookupBeanPostProcessor.getBeanFactory()).isSameAs(mockBeanFactory);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setBeanFactoryToIncompatibleBeanFactoryType() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(String.format("BeanFactory [%1$s] must be an instance of %2$s",
mockBeanFactory.getClass().getName(), ConfigurableListableBeanFactory.class.getSimpleName()));
try {
autoRegionLookupBeanPostProcessor.setBeanFactory(mockBeanFactory);
}
catch (IllegalArgumentException expected) {
autoRegionLookupBeanPostProcessor.setBeanFactory(mockBeanFactory);
assertThat(expected).hasMessage("BeanFactory [%1$s] must be an instance of %2$s",
mockBeanFactory.getClass().getName(), ConfigurableListableBeanFactory.class.getSimpleName());
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@SuppressWarnings("all")
@Test(expected = IllegalArgumentException.class)
public void setBeanFactoryToNull() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(String.format("BeanFactory [null] must be an instance of %s",
ConfigurableListableBeanFactory.class.getSimpleName()));
try {
autoRegionLookupBeanPostProcessor.setBeanFactory(null);
}
catch (IllegalArgumentException expected) {
autoRegionLookupBeanPostProcessor.setBeanFactory(null);
assertThat(expected).hasMessage("BeanFactory [null] must be an instance of %s",
ConfigurableListableBeanFactory.class.getSimpleName());
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@Test(expected = IllegalStateException.class)
public void getBeanFactoryUninitialized() {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory was not properly configured");
try {
autoRegionLookupBeanPostProcessor.getBeanFactory();
}
catch (IllegalStateException expected) {
autoRegionLookupBeanPostProcessor.getBeanFactory();
assertThat(expected).hasMessage("BeanFactory was not properly configured");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@@ -182,7 +190,7 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
verify(mockGemFireCache, times(1)).rootRegions();
for (Region<?, ?> region : expected) {
verifyZeroInteractions(region);
verifyNoInteractions(region);
}
}
@@ -236,13 +244,13 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
autoRegionLookupBeanPostProcessor.setBeanFactory(mockBeanFactory);
autoRegionLookupBeanPostProcessor.registerCacheRegionAsBean(null);
verifyZeroInteractions(mockBeanFactory);
verifyNoInteractions(mockBeanFactory);
}
@Test
public void getBeanNameReturnsRegionFullPath() {
Region mockRegion = mockRegion("/Parent/Child");
Region<?, ?> mockRegion = mockRegion("/Parent/Child");
assertThat(autoRegionLookupBeanPostProcessor.getBeanName(mockRegion)).isEqualTo("/Parent/Child");
@@ -253,7 +261,7 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
@Test
public void getBeanNameReturnsRegionName() {
Region mockRegion = mockRegion("/Example");
Region<?, ?> mockRegion = mockRegion("/Example");
assertThat(autoRegionLookupBeanPostProcessor.getBeanName(mockRegion)).isEqualTo("Example");
@@ -267,7 +275,7 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
Set<Region<?, ?>> mockSubRegions =
CollectionUtils.asSet(mockRegion("one"), mockRegion("two"));
Region mockRegion = mockRegion("parent");
Region<?, ?> mockRegion = mockRegion("parent");
when(mockRegion.subregions(anyBoolean())).thenReturn(mockSubRegions);
@@ -279,7 +287,7 @@ public class AutoRegionLookupBeanPostProcessorUnitTests {
@Test
public void nullSafeSubRegionsWhenSubRegionsIsNull() {
Region mockRegion = mockRegion("parent");
Region<?, ?> mockRegion = mockRegion("parent");
when(mockRegion.subregions(anyBoolean())).thenReturn(null);

34
spring-data-geode/src/test/java/org/springframework/data/gemfire/dao/GemfireDaoSupportUnitTests.java
View File

@@ -17,12 +17,8 @@
package org.springframework.data.gemfire.dao;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
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;
@@ -46,9 +42,6 @@ import org.springframework.data.gemfire.GemfireTemplate;
@RunWith(MockitoJUnitRunner.class)
public class GemfireDaoSupportUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
public Region<?, ?> mockRegion;
@@ -82,9 +75,10 @@ public class GemfireDaoSupportUnitTests {
}
@Test
@SuppressWarnings("rawtypes")
public void createProperlyInitializedGemfireDaoSupportWithTemplate() throws Exception {
public void createProperlyInitializedGemfireDaoSupportWithTemplate() {
GemfireTemplate expectedGemfireTemplate = new GemfireTemplate();
GemfireDaoSupport dao = new TestGemfireDaoSupport();
dao.setGemfireTemplate(expectedGemfireTemplate);
@@ -94,15 +88,21 @@ public class GemfireDaoSupportUnitTests {
assertThat(dao.getGemfireTemplate()).isEqualTo(expectedGemfireTemplate);
}
@Test
public void invalidGemfireDaoSupportInstanceThrowsIllegalStateException() throws Exception {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("A GemFire Cache Region or instance of GemfireTemplate is required");
@Test(expected = IllegalStateException.class)
public void invalidGemfireDaoSupportInstanceThrowsIllegalStateException() {
new TestGemfireDaoSupport().afterPropertiesSet();
try {
new TestGemfireDaoSupport().afterPropertiesSet();
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage("A GemFire Cache Region or instance of GemfireTemplate is required");
assertThat(expected).hasNoCause();
throw expected;
}
}
private static final class TestGemfireDaoSupport extends GemfireDaoSupport {
}
private static final class TestGemfireDaoSupport extends GemfireDaoSupport { }
}

56
spring-data-geode/src/test/java/org/springframework/data/gemfire/eviction/EvictionActionConverterUnitTests.java
View File

@@ -14,35 +14,27 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.eviction;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.EvictionAction;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link EvictionActionConverter}.
* Unit Tests for {@link EvictionActionConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see EvictionActionConverter
* @see org.apache.geode.cache.EvictionAction
* @see org.springframework.data.gemfire.eviction.EvictionActionConverter
* @since 1.6.0
*/
public class EvictionActionConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private EvictionActionConverter converter = new EvictionActionConverter();
private final EvictionActionConverter converter = new EvictionActionConverter();
@After
public void tearDown() {
@@ -51,38 +43,54 @@ public class EvictionActionConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("local_destroy")).isEqualTo(EvictionAction.LOCAL_DESTROY);
assertThat(converter.convert("None")).isEqualTo(EvictionAction.NONE);
assertThat(converter.convert("OverFlow_TO_dIsk")).isEqualTo(EvictionAction.OVERFLOW_TO_DISK);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[invalid_value] is not a valid EvictionAction");
converter.convert("invalid_value");
try {
converter.convert("invalid_value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[invalid_value] is not a valid EvictionAction");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("Local_Destroy");
assertThat(converter.getValue()).isEqualTo(EvictionAction.LOCAL_DESTROY);
converter.setAsText("overflow_to_disk");
assertThat(converter.getValue()).isEqualTo(EvictionAction.OVERFLOW_TO_DISK);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[destroy] is not a valid EvictionAction");
try {
converter.setAsText("destroy");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[destroy] is not a valid EvictionAction");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

51
spring-data-geode/src/test/java/org/springframework/data/gemfire/eviction/EvictionPolicyConverterUnitTests.java
View File

@@ -14,32 +14,25 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.eviction;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link EvictionPolicyConverter}.
* Unit Tests for {@link EvictionPolicyConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see EvictionPolicyConverter
* @see EvictionPolicyType
* @see org.apache.geode.cache.EvictionAttributes
* @see org.springframework.data.gemfire.eviction.EvictionPolicyConverter
* @see org.springframework.data.gemfire.eviction.EvictionPolicyType
* @since 1.6.0
*/
public class EvictionPolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final EvictionPolicyConverter converter = new EvictionPolicyConverter();
@After
@@ -49,39 +42,55 @@ public class EvictionPolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("entry_count")).isEqualTo(EvictionPolicyType.ENTRY_COUNT);
assertThat(converter.convert("Heap_Percentage")).isEqualTo(EvictionPolicyType.HEAP_PERCENTAGE);
assertThat(converter.convert("MEMorY_SiZe")).isEqualTo(EvictionPolicyType.MEMORY_SIZE);
assertThat(converter.convert("NONE")).isEqualTo(EvictionPolicyType.NONE);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[LIFO_MEMORY] is not a valid EvictionPolicyType");
converter.convert("LIFO_MEMORY");
try {
converter.convert("LIFO_MEMORY");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[LIFO_MEMORY] is not a valid EvictionPolicyType");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("heap_percentage");
assertThat(converter.getValue()).isEqualTo(EvictionPolicyType.HEAP_PERCENTAGE);
converter.setAsText("NOne");
assertThat(converter.getValue()).isEqualTo(EvictionPolicyType.NONE);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[LRU_COUNT] is not a valid EvictionPolicyType");
try {
converter.setAsText("LRU_COUNT");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[LRU_COUNT] is not a valid EvictionPolicyType");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

54
spring-data-geode/src/test/java/org/springframework/data/gemfire/expiration/ExpirationActionConverterUnitTests.java
View File

@@ -14,33 +14,26 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.expiration;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.ExpirationAction;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link ExpirationActionConverter}.
* Unit Tests for {@link ExpirationActionConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see ExpirationActionConverter
* @see org.apache.geode.cache.EvictionAction
* @see org.springframework.data.gemfire.expiration.ExpirationActionConverter
* @since 1.6.0
*/
public class ExpirationActionConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final ExpirationActionConverter converter = new ExpirationActionConverter();
@After
@@ -56,33 +49,48 @@ public class ExpirationActionConverterUnitTests {
assertThat(converter.convert("Local_Invalidate")).isEqualTo(ExpirationAction.LOCAL_INVALIDATE);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[illegal_value] is not a valid ExpirationAction");
converter.convert("illegal_value");
try {
converter.convert("illegal_value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[illegal_value] is not a valid ExpirationAction");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("InValidAte");
assertThat(converter.getValue()).isEqualTo(ExpirationAction.INVALIDATE);
converter.setAsText("Local_Destroy");
assertThat(converter.getValue()).isEqualTo(ExpirationAction.LOCAL_DESTROY);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
try {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[destruction] is not a valid ExpirationAction");
try {
converter.setAsText("destruction");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[destruction] is not a valid ExpirationAction");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
assertThat(converter.getValue()).isNull();
}

50
spring-data-geode/src/test/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntityUnitTests.java
View File

@@ -13,19 +13,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.mapping;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.data.annotation.Id;
import org.springframework.data.gemfire.mapping.annotation.Region;
@@ -34,21 +29,17 @@ import org.springframework.data.mapping.MappingException;
import org.springframework.data.util.ClassTypeInformation;
/**
* Unit tests for {@link GemfirePersistentEntity}.
* Unit Tests for {@link GemfirePersistentEntity}.
*
* @author Oliver Gierke
* @author John Blum
* @author Gregory Green
* @see org.junit.Rule
* @see org.junit.Test
* @see org.springframework.data.gemfire.mapping.GemfirePersistentEntity
*/
public class GemfirePersistentEntityUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private GemfireMappingContext mappingContext = new GemfireMappingContext();
private final GemfireMappingContext mappingContext = new GemfireMappingContext();
protected IdentifierAccessor getIdentifierAccessor(Object domainObject) {
return getMappingContextPersistentEntity(domainObject).getIdentifierAccessor(domainObject);
@@ -56,7 +47,7 @@ public class GemfirePersistentEntityUnitTests {
@SuppressWarnings("unchecked")
protected <T> GemfirePersistentEntity<T> getMappingContextPersistentEntity(Object domainObject) {
return this.<T>getMappingContextPersistentEntity((Class<T>) domainObject.getClass());
return this.getMappingContextPersistentEntity((Class<T>) domainObject.getClass());
}
@SuppressWarnings("unchecked")
@@ -86,8 +77,8 @@ public class GemfirePersistentEntityUnitTests {
}
@Test
@SuppressWarnings("unchecked")
public void bigDecimalPersistentPropertyIsNotAnEntity() {
GemfirePersistentEntity<ExampleDomainObject> entity =
getMappingContextPersistentEntity(ExampleDomainObject.class);
@@ -101,7 +92,6 @@ public class GemfirePersistentEntityUnitTests {
}
@Test
@SuppressWarnings("unchecked")
public void bigIntegerPersistentPropertyIsNotAnEntity() {
GemfirePersistentEntity<ExampleDomainObject> entity =
@@ -163,21 +153,25 @@ public class GemfirePersistentEntityUnitTests {
AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity entity =
new AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity();
String expectedMessage = String.format("Attempt to add explicit id property [ssn] but already have id property [id] registered as explicit;"
+ " Please check your object [%s] mapping configuration", entity.getClass().getName());
try {
getIdentifierAccessor(new AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity());
}
catch (MappingException expected) {
exception.expect(MappingException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(expectedMessage);
assertThat(expected).hasMessage("Attempt to add explicit id property [ssn] but already have id property [id] registered as explicit;"
+ " Please check your object [%s] mapping configuration", entity.getClass().getName());
getIdentifierAccessor(new AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity());
assertThat(expected).hasNoCause();
throw expected;
}
}
@SuppressWarnings("unused")
static class AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity {
@Id
private Long id = 1L;
private final Long id = 1L;
@Id
public String getSsn() {
@@ -188,7 +182,7 @@ public class GemfirePersistentEntityUnitTests {
static class IdAnnotatedFieldAndPropertyEntity {
@Id
private Long id = 1L;
private final Long id = 1L;
@Id
public Long getId() {
@@ -196,8 +190,9 @@ public class GemfirePersistentEntityUnitTests {
}
}
@SuppressWarnings("unused")
static class NonIdAnnotatedIdFieldEntity {
private Long id = 123L;
private final Long id = 123L;
}
static class NonIdAnnotatedIdGetterEntity {
@@ -206,16 +201,13 @@ public class GemfirePersistentEntityUnitTests {
}
}
static class NonRegionAnnotatedEntity {
}
static class NonRegionAnnotatedEntity { }
@Region("Foo")
static class NamedRegionAnnotatedEntity {
}
static class NamedRegionAnnotatedEntity { }
@Region
static class UnnamedRegionAnnotatedEntity {
}
static class UnnamedRegionAnnotatedEntity { }
@Region("Example")
@SuppressWarnings("unused")

80
spring-data-geode/src/test/java/org/springframework/data/gemfire/mapping/RegionsTest.java → spring-data-geode/src/test/java/org/springframework/data/gemfire/mapping/RegionsUnitTests.java
View File

@@ -13,14 +13,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.mapping;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -28,27 +25,23 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.geode.cache.Region;
import org.junit.After;
import org.junit.Before;
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.apache.geode.cache.Region;
import org.springframework.data.gemfire.repository.sample.User;
import org.springframework.data.mapping.context.MappingContext;
/**
* The RegionsTest class is a test suite of test cases testing the contract and functionality of the Regions class.
* Unit Tests for {@link Regions}.
*
* @author John J. Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.junit.runner.RunWith
* @see org.mockito.Mockito
* @see org.mockito.junit.MockitoJUnitRunner
* @see org.springframework.data.gemfire.mapping.Regions
@@ -56,26 +49,25 @@ import org.springframework.data.mapping.context.MappingContext;
*/
@SuppressWarnings("unchecked")
@RunWith(MockitoJUnitRunner.class)
public class RegionsTest {
@Rule
public ExpectedException exception = ExpectedException.none();
public class RegionsUnitTests {
@Mock
@SuppressWarnings("rawtypes")
private MappingContext mockMappingContext;
private Region mockUsers;
private Region mockAdminUsers;
private Region mockGuestUsers;
private Region<?, ?> mockUsers;
private Region<?, ?> mockAdminUsers;
private Region<?, ?> mockGuestUsers;
private Regions regions;
protected Region mockRegion(String fullPath) {
private Region<?, ?> mockRegion(String fullPath) {
return mockRegion(fullPath.substring(fullPath.lastIndexOf(Region.SEPARATOR) + 1), fullPath);
}
protected Region mockRegion(String name, String fullPath) {
Region mockRegion = mock(Region.class, name);
private Region<?, ?> mockRegion(String name, String fullPath) {
Region<?, ?> mockRegion = mock(Region.class, name);
when(mockRegion.getName()).thenReturn(name);
when(mockRegion.getFullPath()).thenReturn(fullPath);
@@ -85,6 +77,7 @@ public class RegionsTest {
@Before
public void setup() {
mockUsers = mockRegion("/Users");
mockAdminUsers = mockRegion("/Users/Admin");
mockGuestUsers = mockRegion("/Users/Guest");
@@ -96,6 +89,7 @@ public class RegionsTest {
@After
public void tearDown() {
mockUsers = mockAdminUsers = mockGuestUsers = null;
regions = null;
}
@@ -127,18 +121,24 @@ public class RegionsTest {
assertThat(regions.getRegion(Object.class)).isNull();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void getRegionWithNullEntityTypeThrowsIllegalArgumentException() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Entity type must not be null");
try {
regions.getRegion((Class<?>) null);
}
catch (IllegalArgumentException expected) {
regions.getRegion((Class) null);
assertThat(expected).hasMessage("Entity type must not be null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void getRegionWithNameReturnsRegion() {
assertThat(regions.getRegion("Users")).isSameAs(mockUsers);
assertThat(regions.getRegion("Admin")).isSameAs(mockAdminUsers);
assertThat(regions.getRegion("Guest")).isSameAs(mockGuestUsers);
@@ -146,6 +146,7 @@ public class RegionsTest {
@Test
public void getRegionWithPathReturnsRegion() {
assertThat(regions.getRegion("/Users")).isSameAs(mockUsers);
assertThat(regions.getRegion("/Users/Admin")).isSameAs(mockAdminUsers);
assertThat(regions.getRegion("/Users/Guest")).isSameAs(mockGuestUsers);
@@ -161,31 +162,36 @@ public class RegionsTest {
assertThat(regions.getRegion("/Non/Existing/Region/Path")).isNull();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void getRegionWithNullNameNullPathThrowsIllegalArgumentException() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Region name/path is required");
try {
regions.getRegion((String) null);
}
catch (IllegalArgumentException expected) {
regions.getRegion((String) null);
assertThat(expected).hasMessage("Region name/path is required");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void iterateRegions() {
List<Region> actualRegions = new ArrayList<>(3);
List<Region<?, ?>> actualRegions = new ArrayList<>(3);
for (Region region : regions) {
for (Region<?, ?> region : regions) {
actualRegions.add(region);
}
List<Region> expectedRegions = Arrays.asList(mockUsers, mockAdminUsers, mockGuestUsers);
List<Region<?, ?>> expectedRegions = Arrays.asList(mockUsers, mockAdminUsers, mockGuestUsers);
assertThat(actualRegions).hasSize(expectedRegions.size() * 2);
assertThat(actualRegions).containsAll(expectedRegions);
}
interface Users {
}
interface Users { }
}

41
spring-data-geode/src/test/java/org/springframework/data/gemfire/repository/cdi/CdiExtensionIntegrationTest.java
View File

@@ -14,30 +14,24 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.repository.cdi;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import javax.enterprise.inject.se.SeContainer;
import javax.enterprise.inject.se.SeContainerInitializer;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.CacheFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.CacheFactory;
import org.springframework.data.gemfire.repository.sample.Person;
/**
* The CdiExtensionIntegrationTest class...
* Integration Tests for CDI.
*
* @author John Blum
* @author Mark Paluch
@@ -68,13 +62,15 @@ public class CdiExtensionIntegrationTest {
private static void closeGemfireCache() {
try {
CacheFactory.getAnyInstance().close();
} catch (CacheClosedException ignore) {}
}
catch (CacheClosedException ignore) {}
}
protected void assertIsExpectedPerson(Person actual, Person expected) {
assertThat(actual.getId(), is(equalTo(expected.getId())));
assertThat(actual.getFirstname(), is(equalTo(expected.getFirstname())));
assertThat(actual.getLastname(), is(equalTo(expected.getLastname())));
assertThat(actual.getId()).isEqualTo(expected.getId());
assertThat(actual.getFirstname()).isEqualTo(expected.getFirstname());
assertThat(actual.getLastname()).isEqualTo(expected.getLastname());
}
@Test // DATAGEODE-42
@@ -82,13 +78,13 @@ public class CdiExtensionIntegrationTest {
RepositoryClient repositoryClient = container.select(RepositoryClient.class).get();
assertThat(repositoryClient.getPersonRepository(), is(notNullValue()));
assertThat(repositoryClient.getPersonRepository()).isNotNull();
Person expectedJonDoe = repositoryClient.newPerson("Jon", "Doe");
assertThat(expectedJonDoe, is(notNullValue()));
assertThat(expectedJonDoe.getId(), is(greaterThan(0L)));
assertThat(expectedJonDoe.getName(), is(equalTo("Jon Doe")));
assertThat(expectedJonDoe).isNotNull();
assertThat(expectedJonDoe.getId()).isGreaterThan(0L);
assertThat(expectedJonDoe.getName()).isEqualTo("Jon Doe");
Person savedJonDoe = repositoryClient.save(expectedJonDoe);
@@ -98,8 +94,8 @@ public class CdiExtensionIntegrationTest {
assertIsExpectedPerson(foundJonDoe, expectedJonDoe);
assertThat(repositoryClient.delete(foundJonDoe), is(true));
assertThat(repositoryClient.find(foundJonDoe.getId()), is(nullValue()));
assertThat(repositoryClient.delete(foundJonDoe)).isTrue();
assertThat(repositoryClient.find(foundJonDoe.getId())).isNull();
}
@Test // DATAGEODE-42
@@ -107,7 +103,6 @@ public class CdiExtensionIntegrationTest {
RepositoryClient repositoryClient = container.select(RepositoryClient.class).get();
assertThat(repositoryClient.getPersonRepository().returnOne(), is(equalTo(1)));
assertThat(repositoryClient.getPersonRepository().returnOne()).isEqualTo(1);
}
}

116
spring-data-geode/src/test/java/org/springframework/data/gemfire/repository/cdi/GemfireRepositoryBeanTest.java
View File

@@ -14,23 +14,15 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.repository.cdi;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.isIn;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.data.gemfire.util.ArrayUtils.asArray;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
@@ -46,16 +38,14 @@ import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
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.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.data.gemfire.GemfireAccessor;
@@ -68,14 +58,10 @@ import org.springframework.data.gemfire.util.CollectionUtils;
import org.springframework.data.repository.config.CustomRepositoryImplementationDetector;
/**
* The GemfireRepositoryBeanTest class is a test suite of test cases testing the contract and functionality
* of the GemfireRepositoryBean class.
* Unit Tests for {@link GemfireRepositoryBean}.
*
* @author John Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.junit.rules.ExpectedException
* @see org.junit.runner.RunWith
* @see org.mockito.Mock
* @see org.mockito.Mockito
* @see org.mockito.junit.MockitoJUnitRunner
@@ -83,12 +69,9 @@ import org.springframework.data.repository.config.CustomRepositoryImplementation
* @since 1.0.0
*/
@RunWith(MockitoJUnitRunner.class)
@SuppressWarnings("unchecked")
@SuppressWarnings({ "rawtypes", "unchecked" })
public class GemfireRepositoryBeanTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Mock
private BeanManager mockBeanManager;
@@ -117,7 +100,7 @@ public class GemfireRepositoryBeanTest {
new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(),
newCustomRepositoryImplementationDetector(), null, null);
assertThat(repositoryBean.getDependencyInstance(mockRegionBean, Region.class), is(equalTo(mockRegion)));
assertThat(repositoryBean.getDependencyInstance(mockRegionBean, Region.class)).isEqualTo(mockRegion);
verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBean));
verify(mockBeanManager, times(1))
@@ -131,8 +114,8 @@ public class GemfireRepositoryBeanTest {
new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(),
newCustomRepositoryImplementationDetector(), null, null);
assertThat(repositoryBean.resolveGemfireMappingContext(),
is(equalTo(GemfireRepositoryBean.DEFAULT_GEMFIRE_MAPPING_CONTEXT)));
assertThat(repositoryBean.resolveGemfireMappingContext())
.isEqualTo(GemfireRepositoryBean.DEFAULT_GEMFIRE_MAPPING_CONTEXT);
}
@Test
@@ -154,7 +137,7 @@ public class GemfireRepositoryBeanTest {
GemfireMappingContext actualGemfireMappingContext = repositoryBean.resolveGemfireMappingContext();
assertThat(actualGemfireMappingContext, is(equalTo(expectedGemfireMappingContext)));
assertThat(actualGemfireMappingContext).isEqualTo(expectedGemfireMappingContext);
verify(mockBeanManager, times(1)).createCreationalContext(eq(mockMappingContextBean));
verify(mockBeanManager, times(1)).getReference(eq(mockMappingContextBean), eq(GemfireMappingContext.class),
@@ -172,8 +155,8 @@ public class GemfireRepositoryBeanTest {
Bean<Region> mockRegionBeanOne = mock(Bean.class);
Bean<Region> mockRegionBeanTwo = mock(Bean.class);
when(mockRegionBeanOne.getTypes()).thenReturn(CollectionUtils.asSet((Type) Region.class));
when(mockRegionBeanTwo.getTypes()).thenReturn(CollectionUtils.asSet((Type) Region.class));
when(mockRegionBeanOne.getTypes()).thenReturn(CollectionUtils.asSet(Region.class));
when(mockRegionBeanTwo.getTypes()).thenReturn(CollectionUtils.asSet(Region.class));
when(mockBeanManager.createCreationalContext(any(Bean.class))).thenReturn(mockCreationalContext);
when(mockBeanManager.getReference(eq(mockRegionBeanOne), eq(Region.class), eq(mockCreationalContext)))
.thenReturn(mockRegionOne);
@@ -186,8 +169,8 @@ public class GemfireRepositoryBeanTest {
Iterable<Region> regions = repositoryBean.resolveGemfireRegions();
assertThat(regions, is(notNullValue()));
assertThat(toSet(regions).containsAll(CollectionUtils.asSet(mockRegionOne, mockRegionTwo)), is(true));
assertThat(regions).isNotNull();
assertThat(toSet(regions).containsAll(CollectionUtils.asSet(mockRegionOne, mockRegionTwo))).isTrue();
verify(mockRegionBeanOne, times(1)).getTypes();
verify(mockRegionBeanTwo, times(1)).getTypes();
@@ -211,9 +194,8 @@ public class GemfireRepositoryBeanTest {
new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(),
newCustomRepositoryImplementationDetector(), null, null);
assertThat(repositoryBean.resolveType(mockBean, Region.class), is(equalTo(Region.class)));
assertThat(repositoryBean.resolveType(mockBean, Map.class), isIn(asArray((Type) Map.class,
ConcurrentMap.class, Region.class)));
assertThat(repositoryBean.resolveType(mockBean, Region.class)).isEqualTo(Region.class);
assertThat(repositoryBean.resolveType(mockBean, Map.class)).isIn(Map.class, ConcurrentMap.class, Region.class);
verify(mockBean, times(2)).getTypes();
}
@@ -227,24 +209,24 @@ public class GemfireRepositoryBeanTest {
ParameterizedType mockParameterizedType = mock(ParameterizedType.class);
assertThat(parameterizedTypeMap.getClass(), is(instanceOf(Type.class)));
assertThat(parameterizedTypeMap.getClass().getGenericSuperclass(), is(instanceOf(ParameterizedType.class)));
assertThat(parameterizedTypeMap.getClass().getTypeParameters().length, is(equalTo(2)));
assertThat(parameterizedTypeMap.getClass()).isInstanceOf(Type.class);
assertThat(parameterizedTypeMap.getClass().getGenericSuperclass()).isInstanceOf(ParameterizedType.class);
assertThat(parameterizedTypeMap.getClass().getTypeParameters().length).isEqualTo(2);
when(mockBean.getTypes()).thenReturn(CollectionUtils.asSet((Type) mockParameterizedType));
when(mockBean.getTypes()).thenReturn(CollectionUtils.asSet(mockParameterizedType));
when(mockParameterizedType.getRawType()).thenReturn(parameterizedTypeMap.getClass());
GemfireRepositoryBean<PersonRepository> repositoryBean =
new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(),
newCustomRepositoryImplementationDetector(), null, null);
assertThat(repositoryBean.resolveType(mockBean, Map.class), is(equalTo(mockParameterizedType)));
assertThat(repositoryBean.resolveType(mockBean, Map.class)).isEqualTo(mockParameterizedType);
verify(mockBean, times(1)).getTypes();
verify(mockParameterizedType, times(1)).getRawType();
}
@Test
@Test(expected = IllegalStateException.class)
public void resolveTypeWithUnresolvableType() {
Bean mockBean = mock(Bean.class);
@@ -256,14 +238,18 @@ public class GemfireRepositoryBeanTest {
newCustomRepositoryImplementationDetector(), null, null);
try {
expectedException.expect(IllegalStateException.class);
expectedException.expectCause(is(nullValue(Throwable.class)));
expectedException.expectMessage(is(equalTo(String.format(
"unable to resolve bean instance of type [%1$s] from bean definition [%2$s]",
Region.class, mockBean))));
repositoryBean.resolveType(mockBean, Region.class);
}
catch (IllegalStateException expected) {
assertThat(expected)
.hasMessage("unable to resolve bean instance of type [%1$s] from bean definition [%2$s]",
Region.class, mockBean);
assertThat(expected).hasNoCause();
throw expected;
}
finally {
verify(mockBean, times(1)).getTypes();
}
@@ -271,7 +257,7 @@ public class GemfireRepositoryBeanTest {
@Test
// IntegrationTest
public void createGemfireRepositoryInstanceSuccessfully() throws Exception {
public void createGemfireRepositoryInstanceSuccessfully() {
Bean<Region> mockRegionBean = mock(Bean.class);
@@ -284,7 +270,7 @@ public class GemfireRepositoryBeanTest {
when(mockRegion.getName()).thenReturn("Person");
when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes);
when(mockRegionAttributes.getKeyConstraint()).thenReturn(Long.class);
when(mockRegionBean.getTypes()).thenReturn(CollectionUtils.asSet((Type) Region.class));
when(mockRegionBean.getTypes()).thenReturn(CollectionUtils.asSet(Region.class));
when(mockBeanManager.createCreationalContext(any(Bean.class))).thenReturn(mockCreationalContext);
when(mockBeanManager.getReference(eq(mockRegionBean), eq(Region.class), eq(mockCreationalContext)))
.thenReturn(mockRegion);
@@ -304,20 +290,19 @@ public class GemfireRepositoryBeanTest {
gemfireRepositoryFactory.addRepositoryProxyPostProcessor((factory, repositoryInformation) -> {
try {
assertThat(repositoryInformation.getRepositoryInterface(),
is(equalTo(PersonRepository.class)));
assertThat(repositoryInformation.getRepositoryBaseClass(),
is(equalTo(SimpleGemfireRepository.class)));
assertThat(repositoryInformation.getDomainType(), is(equalTo(Person.class)));
assertThat(repositoryInformation.getIdType(), is(equalTo(Long.class)));
assertThat(factory.getTargetClass(), is(equalTo(SimpleGemfireRepository.class)));
assertThat(repositoryInformation.getRepositoryInterface()).isEqualTo(PersonRepository.class);
assertThat(repositoryInformation.getRepositoryBaseClass())
.isEqualTo(SimpleGemfireRepository.class);
assertThat(repositoryInformation.getDomainType()).isEqualTo(Person.class);
assertThat(repositoryInformation.getIdType()).isEqualTo(Long.class);
assertThat(factory.getTargetClass()).isEqualTo(SimpleGemfireRepository.class);
Object gemfireRepository = factory.getTargetSource().getTarget();
GemfireAccessor gemfireAccessor = TestUtils.readField("template", gemfireRepository);
assertThat(gemfireAccessor, is(notNullValue()));
assertThat(gemfireAccessor.getRegion(), is(equalTo(mockRegion)));
assertThat(gemfireAccessor).isNotNull();
assertThat(gemfireAccessor.getRegion()).isEqualTo(mockRegion);
repositoryProxyPostProcessed.set(true);
}
@@ -333,8 +318,8 @@ public class GemfireRepositoryBeanTest {
GemfireRepository<Person, Long> gemfireRepository =
repositoryBean.create(null, PersonRepository.class);
assertThat(gemfireRepository, is(notNullValue()));
assertThat(repositoryProxyPostProcessed.get(), is(true));
assertThat(gemfireRepository).isNotNull();
assertThat(repositoryProxyPostProcessed.get()).isTrue();
verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBean));
verify(mockBeanManager, times(1)).getReference(eq(mockRegionBean), eq(Region.class),
@@ -345,13 +330,16 @@ public class GemfireRepositoryBeanTest {
verify(mockRegionAttributes, times(1)).getKeyConstraint();
}
class TestMap extends AbstractMap<Long, Object> {
@Override public Set<Entry<Long, Object>> entrySet() {
@SuppressWarnings("unused")
static class TestMap extends AbstractMap<Long, Object> {
@Override
public Set<Entry<Long, Object>> entrySet() {
return Collections.emptySet();
}
}
class Person {}
static class Person {}
interface PersonRepository extends GemfireRepository<Person, Long> { }

74
spring-data-geode/src/test/java/org/springframework/data/gemfire/repository/cdi/GemfireRepositoryExtensionTest.java
View File

@@ -14,14 +14,10 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.repository.cdi;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.isA;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -29,7 +25,6 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
@@ -42,13 +37,12 @@ import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.ProcessBean;
import javax.inject.Qualifier;
import org.apache.geode.cache.Region;
import org.junit.Before;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.apache.geode.cache.Region;
import org.springframework.data.gemfire.mapping.GemfireMappingContext;
import org.springframework.data.gemfire.repository.GemfireRepository;
@@ -76,28 +70,32 @@ public class GemfireRepositoryExtensionTest {
}
protected <T> Set<T> asSet(T... array) {
return new HashSet<T>(Arrays.asList(array));
return new HashSet<>(Arrays.asList(array));
}
protected Annotation mockAnnotation(Class annotationType) {
@SuppressWarnings("rawtypes")
private Annotation mockAnnotation(Class annotationType) {
Annotation mockAnnotation = mock(Annotation.class);
when(mockAnnotation.annotationType()).thenReturn(annotationType);
return mockAnnotation;
}
@Test
@SuppressWarnings("rawtypes")
public void processBeanIdentifiesAndProcessesRegionBeanCorrectly() {
ProcessBean<Region> mockProcessBean = mock(ProcessBean.class);
Bean<Region> mockBean = mock(Bean.class);
when(mockProcessBean.getBean()).thenReturn(mockBean);
when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) Region.class));
when(mockBean.getTypes()).thenReturn(Collections.singleton(Region.class));
assertThat(repositoryExtension.regionBeans.isEmpty(), is(true));
assertThat(repositoryExtension.regionBeans.isEmpty()).isTrue();
repositoryExtension.processBean(mockProcessBean);
assertThat(repositoryExtension.regionBeans.contains(mockBean), is(true));
assertThat(repositoryExtension.regionBeans.contains(mockBean)).isTrue();
verify(mockProcessBean, times(1)).getBean();
verify(mockBean, times(1)).getTypes();
@@ -112,15 +110,15 @@ public class GemfireRepositoryExtensionTest {
mockAnnotation(GemfireRepo.class));
when(mockProcessBean.getBean()).thenReturn(mockBean);
when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) GemfireMappingContext.class));
when(mockBean.getTypes()).thenReturn(Collections.singleton(GemfireMappingContext.class));
when(mockBean.getQualifiers()).thenReturn(expectedQualifiers);
assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true));
assertThat(repositoryExtension.mappingContexts.isEmpty()).isTrue();
repositoryExtension.processBean(mockProcessBean);
assertThat(repositoryExtension.mappingContexts.containsKey(expectedQualifiers), is(true));
assertThat(repositoryExtension.mappingContexts.get(expectedQualifiers), is(equalTo(mockBean)));
assertThat(repositoryExtension.mappingContexts.containsKey(expectedQualifiers)).isTrue();
assertThat(repositoryExtension.mappingContexts.get(expectedQualifiers)).isEqualTo(mockBean);
verify(mockProcessBean, times(1)).getBean();
verify(mockBean, times(2)).getTypes();
@@ -133,15 +131,15 @@ public class GemfireRepositoryExtensionTest {
Bean<Object> mockBean = mock(Bean.class);
when(mockProcessBean.getBean()).thenReturn(mockBean);
when(mockBean.getTypes()).thenReturn(Collections.singleton((Type) Object.class));
when(mockBean.getTypes()).thenReturn(Collections.singleton(Object.class));
assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true));
assertThat(repositoryExtension.regionBeans.isEmpty(), is(true));
assertThat(repositoryExtension.mappingContexts.isEmpty()).isTrue();
assertThat(repositoryExtension.regionBeans.isEmpty()).isTrue();
repositoryExtension.processBean(mockProcessBean);
assertThat(repositoryExtension.mappingContexts.isEmpty(), is(true));
assertThat(repositoryExtension.regionBeans.isEmpty(), is(true));
assertThat(repositoryExtension.mappingContexts.isEmpty()).isTrue();
assertThat(repositoryExtension.regionBeans.isEmpty()).isTrue();
verify(mockProcessBean, times(1)).getBean();
verify(mockBean, times(1)).getTypes();
@@ -154,20 +152,21 @@ public class GemfireRepositoryExtensionTest {
final Set<Annotation> expectedQualifiers = asSet(mockAnnotation(SpringDataRepo.class),
mockAnnotation(GemfireRepo.class));
doAnswer(new Answer<Void>() {
public Void answer(final InvocationOnMock invocation) throws Throwable {
GemfireRepositoryBean<?> repositoryBean = invocation.getArgument(0);
doAnswer((Answer<Void>) invocation -> {
assertThat(repositoryBean, is(notNullValue()));
assertThat((Class<TestRepository>) repositoryBean.getBeanClass(), is(equalTo(TestRepository.class)));
assertThat(repositoryBean.getQualifiers(), is(equalTo(expectedQualifiers)));
GemfireRepositoryBean<?> repositoryBean = invocation.getArgument(0);
return null;
}
assertThat(repositoryBean).isNotNull();
assertThat(repositoryBean.getBeanClass()).isEqualTo(TestRepository.class);
assertThat(repositoryBean.getQualifiers()).isEqualTo(expectedQualifiers);
return null;
}).when(mockAfterBeanDiscovery).addBean(isA(GemfireRepositoryBean.class));
GemfireRepositoryExtension repositoryExtension = new GemfireRepositoryExtension() {
@Override protected Iterable<Map.Entry<Class<?>, Set<Annotation>>> getRepositoryTypes() {
@Override
protected Iterable<Map.Entry<Class<?>, Set<Annotation>>> getRepositoryTypes() {
return Collections.<Class<?>, Set<Annotation>>singletonMap(TestRepository.class, expectedQualifiers).entrySet();
}
};
@@ -178,16 +177,13 @@ public class GemfireRepositoryExtensionTest {
}
@Qualifier
@interface GemfireRepo {
}
@interface GemfireRepo { }
@Qualifier
@interface SpringDataRepo {
}
@interface SpringDataRepo { }
@GemfireRepo
@SpringDataRepo
interface TestRepository extends GemfireRepository<Object, Long> {
}
interface TestRepository extends GemfireRepository<Object, Long> { }
}

33
spring-data-geode/src/test/java/org/springframework/data/gemfire/repository/query/PredicatesUnitTests.java
View File

@@ -15,10 +15,7 @@
*/
package org.springframework.data.gemfire.repository.query;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Collections;
@@ -30,27 +27,31 @@ import org.springframework.data.gemfire.repository.query.Predicates.AtomicPredic
import org.springframework.data.repository.query.parser.Part;
/**
* Unit tests for {@link Predicates}.
* Unit Tests for {@link Predicates}.
*
* @author Oliver Gierke
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.repository.query.Predicates
*/
@SuppressWarnings("unused")
public class PredicatesUnitTests {
@Test
public void atomicPredicateDefaultsAlias() {
Part part = new Part("firstname", Person.class);
Iterator<Integer> indexes = Collections.singletonList(1).iterator();
Predicate predicate = new AtomicPredicate(part, indexes);
assertThat(predicate.toString(null), is("x.firstname = $1"));
assertThat(predicate.toString(null)).isEqualTo("x.firstname = $1");
}
@Test
public void concatenatesAndPredicateCorrectly() {
Part left = new Part("firstname", Person.class);
Part right = new Part("lastname", Person.class);
@@ -58,12 +59,13 @@ public class PredicatesUnitTests {
Predicate predicate = Predicates.create(left, indexes).and(Predicates.create(right, indexes));
assertThat(predicate, is(notNullValue(Predicate.class)));
assertThat(predicate.toString(null), is("x.firstname = $1 AND x.lastname = $2"));
assertThat(predicate).isNotNull();
assertThat(predicate.toString(null)).isEqualTo("x.firstname = $1 AND x.lastname = $2");
}
@Test
public void concatenatesOrPredicateCorrectly() {
Part left = new Part("firstname", Person.class);
Part right = new Part("lastname", Person.class);
@@ -71,20 +73,21 @@ public class PredicatesUnitTests {
Predicate predicate = Predicates.create(left, indexes).or(Predicates.create(right, indexes));
assertThat(predicate, is(notNullValue(Predicate.class)));
assertThat(predicate.toString(null), is(equalTo("x.firstname = $1 OR x.lastname = $2")));
assertThat(predicate).isNotNull();
assertThat(predicate.toString(null)).isEqualTo("x.firstname = $1 OR x.lastname = $2");
}
@Test
public void handlesBooleanBasedPredicateCorrectly() {
Part part = new Part("activeTrue", User.class);
Iterator<Integer> indexes = Collections.singletonList(1).iterator();
Predicates predicate = Predicates.create(part, indexes);
assertThat(predicate, is(notNullValue(Predicate.class)));
assertThat(predicate.toString("user"), is(equalTo("user.active = true")));
assertThat(predicate).isNotNull();
assertThat(predicate.toString("user")).isEqualTo("user.active = true");
}
/**
@@ -92,6 +95,7 @@ public class PredicatesUnitTests {
*/
@Test
public void handlesIgnoreCasePredicateCorrectly() {
Part left = new Part("firstnameIgnoreCase", Person.class);
Part right = new Part("lastnameIgnoreCase", Person.class);
@@ -99,8 +103,9 @@ public class PredicatesUnitTests {
Predicate predicate = Predicates.create(left, indexes).and(Predicates.create(right, indexes));
assertThat(predicate, is(notNullValue(Predicate.class)));
assertThat(predicate.toString("person"), is(equalTo("person.firstname.equalsIgnoreCase($1) AND person.lastname.equalsIgnoreCase($2)")));
assertThat(predicate).isNotNull();
assertThat(predicate.toString("person"))
.isEqualTo("person.firstname.equalsIgnoreCase($1) AND person.lastname.equalsIgnoreCase($2)");
}
static class Person {

72
spring-data-geode/src/test/java/org/springframework/data/gemfire/repository/support/AbstractGemfireRepositoryFactoryIntegrationTests.java
View File

@@ -13,26 +13,20 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.repository.support;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.util.Arrays;
import java.util.List;
import org.apache.geode.cache.Region;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.apache.geode.cache.Region;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.data.gemfire.GemfireTemplate;
@@ -40,17 +34,25 @@ import org.springframework.data.gemfire.mapping.GemfireMappingContext;
import org.springframework.data.gemfire.mapping.Regions;
import org.springframework.data.gemfire.repository.sample.Person;
import org.springframework.data.gemfire.repository.sample.PersonRepository;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.data.gemfire.tests.integration.IntegrationTestsSupport;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration test for {@link GemfireRepositoryFactory}.
* Integration Tests for {@link GemfireRepositoryFactory}.
*
* @author Oliver Gierke
* @author John Blum
* @see org.junit.Test
* @see org.apache.geode.cache.Region
* @see org.springframework.data.gemfire.repository.support.GemfireRepositoryFactory
* @see org.springframework.data.gemfire.tests.integration.IntegrationTestsSupport
* @see org.springframework.test.context.junit4.SpringRunner
*/
@RunWith(SpringJUnit4ClassRunner.class)
public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
@RunWith(SpringRunner.class)
public abstract class AbstractGemfireRepositoryFactoryIntegrationTests extends IntegrationTestsSupport {
@Autowired
@SuppressWarnings("unused")
private List<Region<?, ?>> regions;
private Person boyd;
@@ -65,6 +67,7 @@ public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
@Before
public void setUp() {
dave = new Person(1L, "Dave", "Matthews");
carter = new Person(2L, "Carter", "Beauford");
boyd = new Person(3L, "Boyd", "Tinsley");
@@ -118,9 +121,6 @@ public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
assertResultsFound(repository.findByFirstnameOrLastname("Carter", "Matthews"), carter, dave, oliverAugust);
}
/**
* @see SGF-101
*/
@Test
public void deletesAllEntitiesFromRegions() {
@@ -129,25 +129,16 @@ public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
assertResultsFound(repository.findAll());
}
/**
* @see SGF-113
*/
@Test
public void findsPersonByLastname() {
assertThat(repository.findByLastname("Beauford"), is(carter));
assertThat(repository.findByLastname("Beauford")).isEqualTo(carter);
}
/**
* @see SGF-113
*/
@Test
public void returnsNullForEmptyResultForSingleEntityQuery() {
assertThat(repository.findByLastname("Foo"), is(nullValue()));
assertThat(repository.findByLastname("Foo")).isNull();
}
/**
* @see SGF-113
*/
@Test
public void throwsExceptionForMoreThanOneResultForSingleEntityQuery() {
@@ -155,38 +146,26 @@ public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
repository.findByLastname("Matthews");
fail("Exception expected!");
} catch (IncorrectResultSizeDataAccessException e) {
assertThat(e.getExpectedSize(), is(1));
assertThat(e.getActualSize(), is(2));
assertThat(e.getExpectedSize()).isEqualTo(1);
assertThat(e.getActualSize()).isEqualTo(2);
}
}
/**
* @see SGF-115
*/
@Test
public void executesStartsWithCorrectly() {
assertResultsFound(repository.findByFirstnameStartingWith("Da"), dave);
}
/**
* @see SGF-115
*/
@Test
public void executesEndsWithCorrectly() {
assertResultsFound(repository.findByLastnameEndingWith("ews"), dave, oliverAugust);
}
/**
* @see SGF-115
*/
@Test
public void executesContainsCorrectly() {
assertResultsFound(repository.findByFirstnameContaining("o"), boyd, leroi);
}
/**
* @see SGF-115
*/
@Test
public void executesLikeCorrectly() {
assertResultsFound(repository.findByFirstnameLike("Da%"), dave);
@@ -194,11 +173,12 @@ public abstract class AbstractGemfireRepositoryFactoryIntegrationTests {
@SafeVarargs
private static <T> void assertResultsFound(Iterable<T> result, T... expected) {
assertThat(result, is(notNullValue()));
assertThat(result, is(Matchers.iterableWithSize(expected.length)));
assertThat(result).isNotNull();
assertThat(result).hasSize(expected.length);
for (T element : expected) {
assertThat(result, hasItem(element));
assertThat(result).contains(element);
}
}
}

105
spring-data-geode/src/test/java/org/springframework/data/gemfire/search/lucene/LuceneAccessorUnitTests.java
View File

@@ -14,16 +14,11 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.search.lucene;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.isA;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.eq;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -33,6 +28,12 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.data.gemfire.search.lucene.LuceneAccessor.LuceneQueryExecutor;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.lucene.LuceneIndex;
@@ -40,14 +41,6 @@ import org.apache.geode.cache.lucene.LuceneQueryException;
import org.apache.geode.cache.lucene.LuceneQueryFactory;
import org.apache.geode.cache.lucene.LuceneService;
import org.junit.Before;
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.springframework.dao.DataRetrievalFailureException;
import org.springframework.data.gemfire.search.lucene.support.LuceneAccessorSupport;
@@ -68,9 +61,6 @@ import org.springframework.data.gemfire.search.lucene.support.LuceneAccessorSupp
@RunWith(MockitoJUnitRunner.class)
public class LuceneAccessorUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private GemFireCache mockCache;
@@ -133,8 +123,8 @@ public class LuceneAccessorUnitTests {
}
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithResultLimit() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
@@ -150,8 +140,8 @@ public class LuceneAccessorUnitTests {
}
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithResultLimitAndPageSize() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
@@ -168,6 +158,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveCacheReturnsConfiguredCache() {
luceneAccessor.setCache(mockCache);
assertThat(luceneAccessor.getCache()).isSameAs(mockCache);
@@ -176,6 +167,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
luceneAccessor.setLuceneService(mockLuceneService);
assertThat(luceneAccessor.getLuceneService()).isSameAs(mockLuceneService);
@@ -184,7 +176,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceLooksUpLuceneService() {
doReturn(mockCache).when(luceneAccessor).resolveCache();
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService(eq(mockCache));
assertThat(luceneAccessor.getLuceneService()).isNull();
@@ -196,16 +188,22 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceThrowsIllegalArgumentExceptionWhenCacheIsNull() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Cache reference was not properly configured");
luceneAccessor.resolveLuceneService(null);
try {
luceneAccessor.resolveLuceneService(null);
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("Cache reference was not properly configured");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsConfiguredIndexName() {
luceneAccessor.setIndexName("TestIndex");
assertThat(luceneAccessor.getIndexName()).isEqualTo("TestIndex");
@@ -215,8 +213,8 @@ public class LuceneAccessorUnitTests {
}
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsLuceneIndexName() {
luceneAccessor.setLuceneIndex(mockLuceneIndex);
when(mockLuceneIndex.getName()).thenReturn("MockIndex");
@@ -229,20 +227,26 @@ public class LuceneAccessorUnitTests {
}
@Test
@SuppressWarnings("all")
public void resolveIndexNameThrowsIllegalStateExceptionWhenIndexNameIsUnresolvable() {
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
assertThat(luceneAccessor.getLuceneIndex()).isNull();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("The name of the Lucene Index could not be resolved");
try {
luceneAccessor.resolveIndexName();
}
catch (IllegalStateException expected) {
luceneAccessor.resolveIndexName();
assertThat(expected).hasMessage("The name of the Lucene Index could not be resolved");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void resolveRegionPathReturnsConfiguredRegionPath() {
luceneAccessor.setRegionPath("/Example");
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
@@ -250,8 +254,8 @@ public class LuceneAccessorUnitTests {
}
@Test
@SuppressWarnings("all")
public void resolveRegionPathReturnsRegionFullPath() {
when(mockRegion.getFullPath()).thenReturn("/Example");
luceneAccessor.setRegion(mockRegion);
@@ -263,21 +267,28 @@ public class LuceneAccessorUnitTests {
verify(mockRegion, times(1)).getFullPath();
}
@Test
@Test(expected = IllegalStateException.class)
public void resolveRegionPathThrowsIllegalStatueExceptionWhenRegionPathIsUnresolvable() {
assertThat(luceneAccessor.getRegion()).isNull();
assertThat(luceneAccessor.getRegionPath()).isNullOrEmpty();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Region path could not be resolved");
try {
luceneAccessor.resolveRegionPath();
}
catch (IllegalStateException expected) {
luceneAccessor.resolveRegionPath();
assertThat(expected).hasMessage("Region path could not be resolved");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@SuppressWarnings("unchecked")
public void doFind() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenReturn("test");
@@ -288,22 +299,27 @@ public class LuceneAccessorUnitTests {
verify(mockQueryExecutor, times(1)).execute();
}
@Test
@Test(expected = DataRetrievalFailureException.class)
@SuppressWarnings("unchecked")
public void doFindHandlesLuceneQueryException() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenThrow(new LuceneQueryException("test"));
try {
exception.expect(DataRetrievalFailureException.class);
exception.expectCause(isA(LuceneQueryException.class));
exception.expectMessage(containsString(
"Failed to execute Lucene Query [title : Up Shit Creek Without a Paddle] on Region [/Example] with Lucene Index [ExampleIndex]"));
luceneAccessor.doFind(mockQueryExecutor, "title : Up Shit Creek Without a Paddle",
"/Example", "ExampleIndex");
}
catch (DataRetrievalFailureException expected) {
assertThat(expected)
.hasMessageContaining("Failed to execute Lucene Query [title : Up Shit Creek Without a Paddle] on Region [/Example] with Lucene Index [ExampleIndex]");
assertThat(expected).hasCauseInstanceOf(LuceneQueryException.class);
throw expected;
}
finally {
verify(mockQueryExecutor, times(1)).execute();
}
@@ -311,6 +327,7 @@ public class LuceneAccessorUnitTests {
@Test
public void luceneAccessorInitializedCorrectly() {
luceneAccessor.setCache(mockCache);
luceneAccessor.setIndexName("ExampleIndex");
luceneAccessor.setLuceneIndex(mockLuceneIndex);

42
spring-data-geode/src/test/java/org/springframework/data/gemfire/search/lucene/LuceneServiceFactoryBeanUnitTests.java
View File

@@ -14,36 +14,29 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.search.lucene;
import static org.assertj.core.api.Java6Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.eq;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.lucene.LuceneService;
import org.junit.Before;
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.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.lucene.LuceneService;
/**
* Unit tests for {@link LuceneServiceFactoryBean}.
* Unit Tests for {@link LuceneServiceFactoryBean}.
*
* @author John Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.junit.runner.RunWith
* @see org.mockito.Mock
* @see org.mockito.Mockito
* @see org.mockito.Spy
@@ -54,9 +47,6 @@ import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class LuceneServiceFactoryBeanUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private GemFireCache mockCache;
@@ -73,6 +63,7 @@ public class LuceneServiceFactoryBeanUnitTests {
@Test
public void setAndGetCache() {
assertThat(factoryBean.getCache()).isNull();
factoryBean.setCache(mockCache);
@@ -86,6 +77,7 @@ public class LuceneServiceFactoryBeanUnitTests {
@Test
public void afterPropertiesSetInitializesLuceneService() throws Exception {
assertThat(factoryBean.getObject()).isNull();
factoryBean.setCache(mockCache);
@@ -96,25 +88,33 @@ public class LuceneServiceFactoryBeanUnitTests {
verify(factoryBean, times(1)).resolveLuceneService(eq(mockCache));
}
@Test
@Test(expected = IllegalStateException.class)
public void afterPropertiesSetThrowsIllegalStateExceptionWhenGemFireCacheIsNull() throws Exception {
assertThat(factoryBean.getCache()).isNull();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("A reference to the GemFireCache was not properly configured");
try {
factoryBean.afterPropertiesSet();
}
catch (IllegalStateException expected) {
factoryBean.afterPropertiesSet();
assertThat(expected).hasMessage("A reference to the GemFireCache was not properly configured");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void getObjectTypeBeforeInitialization() throws Exception {
assertThat(factoryBean.getObject()).isNull();
assertThat(factoryBean.getObjectType()).isEqualTo(LuceneService.class);
}
@Test
public void getObjectTypeAfterInitialization() throws Exception {
factoryBean.setCache(mockCache);
factoryBean.afterPropertiesSet();

46
spring-data-geode/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverterUnitTests.java
View File

@@ -13,17 +13,12 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.server;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* Unit tests for {@link SubscriptionEvictionPolicyConverter}.
@@ -36,9 +31,6 @@ import org.junit.rules.ExpectedException;
*/
public class SubscriptionEvictionPolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final SubscriptionEvictionPolicyConverter converter = new SubscriptionEvictionPolicyConverter();
@After
@@ -48,36 +40,54 @@ public class SubscriptionEvictionPolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("EnTry")).isEqualTo(SubscriptionEvictionPolicy.ENTRY);
assertThat(converter.convert("MEM")).isEqualTo(SubscriptionEvictionPolicy.MEM);
assertThat(converter.convert("nONE")).isEqualTo(SubscriptionEvictionPolicy.NONE);
assertThat(converter.convert("NOne")).isEqualTo(SubscriptionEvictionPolicy.NONE);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[memory] is not a valid SubscriptionEvictionPolicy");
converter.setAsText("memory");
try {
converter.setAsText("memory");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[memory] is not a valid SubscriptionEvictionPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAsText() {
assertThat(converter.getValue()).isNull();
converter.setAsText("enTRY");
assertThat(converter.getValue()).isEqualTo(SubscriptionEvictionPolicy.ENTRY);
converter.setAsText("MEm");
assertThat(converter.getValue()).isEqualTo(SubscriptionEvictionPolicy.MEM);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[KEYS] is not a valid SubscriptionEvictionPolicy");
converter.setAsText("KEYS");
try {
converter.setAsText("KEYS");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[KEYS] is not a valid SubscriptionEvictionPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
}

203
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/ConnectionEndpointListTest.java
View File

@@ -13,32 +13,22 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
* The ConnectionEndpointListTest class is a test suite of test cases testing the contract and functionality
* of the ConnectionEndpointList class.
* Unit Tests for {@link ConnectionEndpointList}.
*
* @author John Blum
* @see java.net.InetSocketAddress
* @see org.junit.Rule
* @see org.junit.Test
* @see org.junit.rules.ExpectedException
* @see org.springframework.data.gemfire.support.ConnectionEndpoint
@@ -47,23 +37,22 @@ import org.junit.rules.ExpectedException;
*/
public class ConnectionEndpointListTest {
@Rule
public ExpectedException exception = ExpectedException.none();
protected ConnectionEndpoint newConnectionEndpoint(String host, int port) {
private ConnectionEndpoint newConnectionEndpoint(String host, int port) {
return new ConnectionEndpoint(host, port);
}
@Test
public void constructNewEmptyConnectionEndpointList() {
ConnectionEndpointList connectionEndpoints = new ConnectionEndpointList();
assertThat(connectionEndpoints.isEmpty(), is(true));
assertThat(connectionEndpoints.size(), is(equalTo(0)));
assertThat(connectionEndpoints.isEmpty()).isTrue();
assertThat(connectionEndpoints.size()).isEqualTo(0);
}
@Test
public void constructNewInitializedConnectionEndpointList() {
ConnectionEndpoint[] connectionEndpoints = {
newConnectionEndpoint("jambox", 1234),
newConnectionEndpoint("skullbox", 9876)
@@ -71,18 +60,19 @@ public class ConnectionEndpointListTest {
ConnectionEndpointList connectionEndpointList = new ConnectionEndpointList(connectionEndpoints);
assertThat(connectionEndpointList.isEmpty(), is(false));
assertThat(connectionEndpointList.size(), is(equalTo(connectionEndpoints.length)));
assertThat(connectionEndpointList.isEmpty()).isFalse();
assertThat(connectionEndpointList.size()).isEqualTo(connectionEndpoints.length);
int index = 0;
for (ConnectionEndpoint connectionEndpoint : connectionEndpointList) {
assertThat(connectionEndpoint, is(equalTo(connectionEndpoints[index++])));
assertThat(connectionEndpoint).isEqualTo(connectionEndpoints[index++]);
}
}
@Test
public void fromConnectionEndpoints() {
ConnectionEndpoint[] connectionEndpoints = {
newConnectionEndpoint("boombox", 10334),
newConnectionEndpoint("skullbox", 40404),
@@ -91,18 +81,19 @@ public class ConnectionEndpointListTest {
ConnectionEndpointList list = ConnectionEndpointList.from(connectionEndpoints);
assertThat(list, is(notNullValue()));
assertThat(list.size(), is(equalTo(connectionEndpoints.length)));
assertThat(list).isNotNull();
assertThat(list.size()).isEqualTo(connectionEndpoints.length);
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(connectionEndpoint, is(equalTo(connectionEndpoints[index++])));
assertThat(connectionEndpoint).isEqualTo(connectionEndpoints[index++]);
}
}
@Test
public void fromInetSocketAddresses() {
InetSocketAddress[] inetSocketAddresses = {
new InetSocketAddress("localhost", 1234),
new InetSocketAddress("localhost", 9876)
@@ -110,58 +101,63 @@ public class ConnectionEndpointListTest {
ConnectionEndpointList list = ConnectionEndpointList.from(inetSocketAddresses);
assertThat(list, is(notNullValue()));
assertThat(list.size(), is(equalTo(inetSocketAddresses.length)));
assertThat(list).isNotNull();
assertThat(list.size()).isEqualTo(inetSocketAddresses.length);
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(connectionEndpoint.getHost(), is(equalTo(inetSocketAddresses[index].getHostString())));
assertThat(connectionEndpoint.getPort(), is(equalTo(inetSocketAddresses[index++].getPort())));
assertThat(connectionEndpoint.getHost()).isEqualTo(inetSocketAddresses[index].getHostString());
assertThat(connectionEndpoint.getPort()).isEqualTo(inetSocketAddresses[index++].getPort());
}
}
@Test
@SuppressWarnings("unchecked")
@SuppressWarnings({ "rawtypes", "unchecked" })
public void fromIterableInetSocketAddressesIsNullSafe() {
ConnectionEndpointList list = ConnectionEndpointList.from((Iterable) null);
assertThat(list, is(notNullValue()));
assertThat(list.isEmpty(), is(true));
assertThat(list).isNotNull();
assertThat(list.isEmpty()).isTrue();
}
@Test
public void parse() {
ConnectionEndpointList list = ConnectionEndpointList.parse(24842, "mercury[11235]", "venus", "[12480]", "[]",
"jupiter[]", "saturn[1, 2-Hundred and 34.zero5]", "neptune[four]");
ConnectionEndpointList list =
ConnectionEndpointList.parse(24842, "mercury[11235]", "venus", "[12480]", "[]",
"jupiter[]", "saturn[1, 2-Hundred and 34.zero5]", "neptune[four]");
String[] expectedHostPorts = { "mercury[11235]", "venus[24842]", "localhost[12480]", "localhost[24842]",
"jupiter[24842]", "saturn[12345]", "neptune[24842]" };
assertThat(list, is(notNullValue()));
assertThat(list.size(), is(equalTo(expectedHostPorts.length)));
assertThat(list).isNotNull();
assertThat(list.size()).isEqualTo(expectedHostPorts.length);
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(connectionEndpoint.toString(), is(equalTo(expectedHostPorts[index++])));
assertThat(connectionEndpoint.toString()).isEqualTo(expectedHostPorts[index++]);
}
}
@Test
public void parseWithEmptyHostsPortsArgument() {
ConnectionEndpointList list = ConnectionEndpointList.parse(1234);
assertThat(list, is(notNullValue()));
assertThat(list.isEmpty(), is(true));
assertThat(list).isNotNull();
assertThat(list.isEmpty()).isTrue();
}
@Test
@SuppressWarnings("unchecked")
@SuppressWarnings({ "rawtypes", "unchecked" })
public void addAdditionalConnectionEndpoints() {
ConnectionEndpointList list = new ConnectionEndpointList();
assertThat(list.isEmpty(), is(true));
assertThat(list.isEmpty()).isTrue();
ConnectionEndpoint[] connectionEndpointsArray = { newConnectionEndpoint("Mercury", 1111) };
@@ -176,10 +172,9 @@ public class ConnectionEndpointListTest {
newConnectionEndpoint("Pluto", 9999)
);
assertThat(list.add(connectionEndpointsArray).add(connectionEndpointsIterable),
is(sameInstance(list)));
assertThat(list.add(connectionEndpointsArray).add(connectionEndpointsIterable)).isSameAs(list);
List<ConnectionEndpoint> expected = new ArrayList<ConnectionEndpoint>(9);
List<ConnectionEndpoint> expected = new ArrayList<>(9);
expected.add(connectionEndpointsArray[0]);
expected.addAll((List) connectionEndpointsIterable);
@@ -187,12 +182,13 @@ public class ConnectionEndpointListTest {
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(connectionEndpoint, is(equalTo(expected.get(index++))));
assertThat(connectionEndpoint).isEqualTo(expected.get(index++));
}
}
@Test
public void findByHostName() {
ConnectionEndpointList list = new ConnectionEndpointList(
newConnectionEndpoint("Earth", 10334),
newConnectionEndpoint("Earth", 40404),
@@ -202,37 +198,38 @@ public class ConnectionEndpointListTest {
newConnectionEndpoint("Neptune", 12345)
);
assertThat(list.size(), is(equalTo(6)));
assertThat(list.size()).isEqualTo(6);
ConnectionEndpointList result = list.findBy("Earth");
assertThat(result, is(notNullValue()));
assertThat(result.size(), is(equalTo(2)));
assertThat(result).isNotNull();
assertThat(result.size()).isEqualTo(2);
String[] expected = { "Earth[10334]", "Earth[40404]" };
int index = 0;
for (ConnectionEndpoint connectionEndpoint : result) {
assertThat(connectionEndpoint.toString(), is(equalTo(expected[index++])));
assertThat(connectionEndpoint.toString()).isEqualTo(expected[index++]);
}
result = list.findBy("Saturn");
assertThat(result, is(notNullValue()));
assertThat(result.isEmpty(), is(false));
assertThat(result.size(), is(equalTo(1)));
assertThat(result.iterator().next().toString(), is(equalTo("Saturn[9876]")));
assertThat(result).isNotNull();
assertThat(result.isEmpty()).isFalse();
assertThat(result.size()).isEqualTo(1);
assertThat(result.iterator().next().toString()).isEqualTo("Saturn[9876]");
result = list.findBy("Pluto");
assertThat(result, is(notNullValue()));
assertThat(result.isEmpty(), is(true));
assertThat(result.size(), is(equalTo(0)));
assertThat(result).isNotNull();
assertThat(result.isEmpty()).isTrue();
assertThat(result.size()).isEqualTo(0);
}
@Test
public void findByPortNumber() {
ConnectionEndpointList list = new ConnectionEndpointList(
newConnectionEndpoint("Earth", 10334),
newConnectionEndpoint("Earth", 40404),
@@ -242,87 +239,90 @@ public class ConnectionEndpointListTest {
newConnectionEndpoint("Neptune", 12345)
);
assertThat(list.size(), is(equalTo(6)));
assertThat(list.size()).isEqualTo(6);
ConnectionEndpointList result = list.findBy(10334);
assertThat(result, is(notNullValue()));
assertThat(result.size(), is(equalTo(2)));
assertThat(result).isNotNull();
assertThat(result.size()).isEqualTo(2);
String[] expected = { "Earth[10334]", "Mars[10334]" };
int index = 0;
for (ConnectionEndpoint connectionEndpoint : result) {
assertThat(connectionEndpoint.toString(), is(equalTo(expected[index++])));
assertThat(connectionEndpoint.toString()).isEqualTo(expected[index++]);
}
result = list.findBy(1234);
assertThat(result, is(notNullValue()));
assertThat(result.size(), is(equalTo(1)));
assertThat(result.iterator().next().toString(), is(equalTo("Jupiter[1234]")));
assertThat(result).isNotNull();
assertThat(result.size()).isEqualTo(1);
assertThat(result.iterator().next().toString()).isEqualTo("Jupiter[1234]");
result = list.findBy(80);
assertThat(result, is(notNullValue()));
assertThat(result.isEmpty(), is(true));
assertThat(result).isNotNull();
assertThat(result.isEmpty()).isTrue();
}
@Test
public void findOneByHostName() {
ConnectionEndpointList list = new ConnectionEndpointList();
assertThat(list.findOne("localhost"), is(nullValue()));
assertThat(list.findOne("localhost")).isNull();
list.add(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne("localhost"), is(nullValue()));
assertThat(list.findOne("skullbox"), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne("localhost")).isNull();
assertThat(list.findOne("skullbox")).isEqualTo(newConnectionEndpoint("skullbox", 11235));
list.add(newConnectionEndpoint("toolbox", 12480));
assertThat(list.findOne("boombox"), is(nullValue()));
assertThat(list.findOne("localhost"), is(nullValue()));
assertThat(list.findOne("skullbox"), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne("toolbox"), is(equalTo(newConnectionEndpoint("toolbox", 12480))));
assertThat(list.findOne("boombox")).isNull();
assertThat(list.findOne("localhost")).isNull();
assertThat(list.findOne("skullbox")).isEqualTo(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne("toolbox")).isEqualTo(newConnectionEndpoint("toolbox", 12480));
list.add(newConnectionEndpoint("skullbox", 10334));
assertThat(list.findOne("localhost"), is(nullValue()));
assertThat(list.findOne("boombox"), is(nullValue()));
assertThat(list.findOne("skullbox"), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne("toolbox"), is(equalTo(newConnectionEndpoint("toolbox", 12480))));
assertThat(list.findOne("localhost")).isNull();
assertThat(list.findOne("boombox")).isNull();
assertThat(list.findOne("skullbox")).isEqualTo(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne("toolbox")).isEqualTo(newConnectionEndpoint("toolbox", 12480));
}
@Test
public void findOneByPortNumber() {
ConnectionEndpointList list = new ConnectionEndpointList();
assertThat(list.findOne(10334), is(nullValue()));
assertThat(list.findOne(10334)).isNull();
list.add(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne(10334), is(nullValue()));
assertThat(list.findOne(11235), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne(10334)).isNull();
assertThat(list.findOne(11235)).isEqualTo(newConnectionEndpoint("skullbox", 11235));
list.add(newConnectionEndpoint("toolbox", 12480));
assertThat(list.findOne(10334), is(nullValue()));
assertThat(list.findOne(40404), is(nullValue()));
assertThat(list.findOne(11235), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne(12480), is(equalTo(newConnectionEndpoint("toolbox", 12480))));
assertThat(list.findOne(10334)).isNull();
assertThat(list.findOne(40404)).isNull();
assertThat(list.findOne(11235)).isEqualTo(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne(12480)).isEqualTo(newConnectionEndpoint("toolbox", 12480));
list.add(newConnectionEndpoint("boombox", 11235));
assertThat(list.findOne(10334), is(nullValue()));
assertThat(list.findOne(40404), is(nullValue()));
assertThat(list.findOne(11235), is(equalTo(newConnectionEndpoint("skullbox", 11235))));
assertThat(list.findOne(12480), is(equalTo(newConnectionEndpoint("toolbox", 12480))));
assertThat(list.findOne(10334)).isNull();
assertThat(list.findOne(40404)).isNull();
assertThat(list.findOne(11235)).isEqualTo(newConnectionEndpoint("skullbox", 11235));
assertThat(list.findOne(12480)).isEqualTo(newConnectionEndpoint("toolbox", 12480));
}
@Test
public void toArrayFromList() {
ConnectionEndpointList list = ConnectionEndpointList.from(
newConnectionEndpoint("boombox", 11235),
newConnectionEndpoint("skullbox", 12480),
@@ -330,62 +330,65 @@ public class ConnectionEndpointListTest {
ConnectionEndpoint[] connectionEndpointArray = list.toArray();
assertThat(connectionEndpointArray, is(notNullValue()));
assertThat(connectionEndpointArray.length, is(equalTo(list.size())));
assertThat(connectionEndpointArray).isNotNull();
assertThat(connectionEndpointArray.length).isEqualTo(list.size());
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(connectionEndpointArray[index++], is(equalTo(connectionEndpoint)));
assertThat(connectionEndpointArray[index++]).isEqualTo(connectionEndpoint);
}
}
@Test
public void toArrayFromEmptyList() {
ConnectionEndpoint[] connectionEndpoints = new ConnectionEndpointList().toArray();
assertThat(connectionEndpoints, is(notNullValue()));
assertThat(connectionEndpoints.length, is(equalTo(0)));
assertThat(connectionEndpoints).isNotNull();
assertThat(connectionEndpoints.length).isEqualTo(0);
}
@Test
public void toInetSocketAddressesFromList() {
ConnectionEndpointList list = ConnectionEndpointList.from(
newConnectionEndpoint("localhost", 10334),
newConnectionEndpoint("localhost", 40404));
List<InetSocketAddress> socketAddresses = list.toInetSocketAddresses();
assertThat(socketAddresses, is(notNullValue()));
assertThat(socketAddresses.size(), is(equalTo(list.size())));
assertThat(socketAddresses).isNotNull();
assertThat(socketAddresses.size()).isEqualTo(list.size());
int index = 0;
for (ConnectionEndpoint connectionEndpoint : list) {
assertThat(socketAddresses.get(index).getHostName(), is(equalTo(connectionEndpoint.getHost())));
assertThat(socketAddresses.get(index++).getPort(), is(equalTo(connectionEndpoint.getPort())));
assertThat(socketAddresses.get(index).getHostName()).isEqualTo(connectionEndpoint.getHost());
assertThat(socketAddresses.get(index++).getPort()).isEqualTo(connectionEndpoint.getPort());
}
}
@Test
public void toInetSocketAddressesFromEmptyList() {
List<InetSocketAddress> socketAddresses = new ConnectionEndpointList().toInetSocketAddresses();
assertThat(socketAddresses, is(notNullValue()));
assertThat(socketAddresses.isEmpty(), is(true));
assertThat(socketAddresses).isNotNull();
assertThat(socketAddresses.isEmpty()).isTrue();
}
@Test
public void toStringFromList() {
ConnectionEndpointList list = ConnectionEndpointList.parse(10334,
"skullbox[12480]", "saturn[ 1 12 3 5]", "neptune");
assertThat(list.toString(), is(equalTo("[skullbox[12480], saturn[11235], neptune[10334]]")));
assertThat(list.toString()).isEqualTo("[skullbox[12480], saturn[11235], neptune[10334]]");
}
@Test
public void toStringFromEmptyList() {
assertThat(new ConnectionEndpointList().toString(), is(equalTo("[]")));
assertThat(new ConnectionEndpointList().toString()).isEqualTo("[]");
}
}

85
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/DeclarableSupportUnitTests.java
View File

@@ -14,19 +14,14 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.support;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.junit.After;
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.Spy;
@@ -35,10 +30,9 @@ import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.beans.factory.BeanFactory;
/**
* Unit tests for {@link DeclarableSupport}.
* Unit Tests for {@link DeclarableSupport}.
*
* @author John Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.mockito.Mock
* @see org.mockito.Mockito
@@ -49,9 +43,6 @@ import org.springframework.beans.factory.BeanFactory;
@RunWith(MockitoJUnitRunner.class)
public class DeclarableSupportUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private BeanFactory mockBeanFactoryOne;
@@ -111,6 +102,7 @@ public class DeclarableSupportUnitTests {
@Test
public void locateBeanFactoryWithUnknownKeyHavingMultipleBeanFactoriesRegisteredThrowsIllegalArgumentException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyOne", mockBeanFactoryOne);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyTwo", mockBeanFactoryTwo);
@@ -118,54 +110,81 @@ public class DeclarableSupportUnitTests {
assertThat(testDeclarableSupport.getBeanFactoryKey()).isEqualTo("keyOne");
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory for key [UnknownKey] was not found");
try {
testDeclarableSupport.locateBeanFactory("UnknownKey");
}
catch (IllegalArgumentException expected) {
testDeclarableSupport.locateBeanFactory("UnknownKey");
assertThat(expected).hasMessage("BeanFactory for key [UnknownKey] was not found");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@Test(expected = IllegalStateException.class)
public void locateBeanFactoryWithoutKeyHavingMultipleBeanFactoriesRegisteredThrowsIllegalStateException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyOne", mockBeanFactoryOne);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyTwo", mockBeanFactoryTwo);
assertThat(testDeclarableSupport.getBeanFactoryKey()).isNull();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory key must be specified when more than one BeanFactory [keyOne, keyTwo]"
+ " is registered");
try {
testDeclarableSupport.locateBeanFactory();
}
catch (IllegalStateException expected) {
testDeclarableSupport.locateBeanFactory();
assertThat(expected)
.hasMessage("BeanFactory key must be specified when more than one BeanFactory [keyOne, keyTwo] is registered");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@Test(expected = IllegalStateException.class)
public void locateBeanFactoryWithKeyWhenNoBeanFactoriesAreRegisteredThrowsIllegalStateException() {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).isEmpty();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("A BeanFactory was not initialized;"
+ " Please verify the useBeanFactoryLocator property was properly set");
try {
testDeclarableSupport.locateBeanFactory("testKey");
}
catch (IllegalStateException expected) {
testDeclarableSupport.locateBeanFactory("testKey");
assertThat(expected).hasMessage("A BeanFactory was not initialized;"
+ " Please verify the useBeanFactoryLocator property was properly set");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@Test(expected = IllegalStateException.class)
public void locateBeanFactoryWithoutKeyWhenNoBeanFactoriesAreRegisteredThrowsIllegalStateException() {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).isEmpty();
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("A BeanFactory was not initialized;"
+ " Please verify the useBeanFactoryLocator property was properly set");
try {
testDeclarableSupport.locateBeanFactory();
}
catch (IllegalStateException expected) {
testDeclarableSupport.locateBeanFactory();
assertThat(expected).hasMessage("A BeanFactory was not initialized;"
+ " Please verify the useBeanFactoryLocator property was properly set");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void getBeanFactoryReturnsBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyOne", mockBeanFactoryOne);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyTwo", mockBeanFactoryTwo);
@@ -177,7 +196,9 @@ public class DeclarableSupportUnitTests {
@Test
public void closeIsSuccessful() {
testDeclarableSupport.close();
verify(testDeclarableSupport, times(1)).close();
}
}

181
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/GemfireBeanFactoryLocatorUnitTests.java
View File

@@ -14,18 +14,16 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.support;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import static org.springframework.data.gemfire.support.GemfireBeanFactoryLocator.BeanFactoryReference.UNINITIALIZED_BEAN_FACTORY_REFERENCE_MESSAGE;
import static org.springframework.data.gemfire.support.GemfireBeanFactoryLocator.newBeanFactoryLocator;
@@ -37,9 +35,7 @@ import java.util.Set;
import org.junit.After;
import org.junit.Before;
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;
@@ -47,10 +43,9 @@ import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.beans.factory.BeanFactory;
/**
* Unit tests for {@link GemfireBeanFactoryLocator}.
* Unit Tests for {@link GemfireBeanFactoryLocator}.
*
* @author John Blum
* @see org.junit.Rule
* @see org.junit.Test
* @see org.mockito.Mock
* @see org.mockito.Mockito
@@ -61,9 +56,6 @@ import org.springframework.beans.factory.BeanFactory;
@RunWith(MockitoJUnitRunner.class)
public class GemfireBeanFactoryLocatorUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
@Mock
private BeanFactory mockBeanFactory;
@@ -79,6 +71,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void newUninitializedBeanFactorLocator() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator();
assertThat(beanFactoryLocator).isNotNull();
@@ -90,6 +83,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void newInitializedBeanFactoryLocator() {
when(mockBeanFactory.getAliases(anyString())).thenReturn(new String[0]);
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator(mockBeanFactory, "AssociatedBeanName");
@@ -106,6 +100,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void newInitializedBeanFactoryLocatorWithNullBeanFactoryAndSpecifiedBeanName() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator(null, "MyBeanName");
assertThat(beanFactoryLocator).isNotNull();
@@ -115,17 +110,24 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(beanFactoryLocator.getAssociatedBeanNameWithAliases()).isEmpty();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void newInitializedBeanFactoryLocatorWithNonNullBeanFactoryAndUnspecifiedBeanNameThrowsIllegalArgumentException() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("associatedBeanName must be specified when BeanFactory is not null");
newBeanFactoryLocator(mockBeanFactory, " ");
try {
newBeanFactoryLocator(mockBeanFactory, " ");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("associatedBeanName must be specified when BeanFactory is not null");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void resolveBeanFactoryReturnsResolvedBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("MyBeanKey", mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).hasSize(1);
@@ -134,33 +136,42 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void resolveBeanFactoryWithNoRegisteredBeanFactoriesAndAnyKeyReturnsNull() {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).isEmpty();
assertThat(GemfireBeanFactoryLocator.resolveBeanFactory("MyBeanKey")).isNull();
assertThat(GemfireBeanFactoryLocator.resolveBeanFactory("AnotherBeanKey")).isNull();
assertThat(GemfireBeanFactoryLocator.resolveBeanFactory("YetAnotherBeanKey")).isNull();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void resolveBeanFactoryWithRegisteredBeanFactoriesAndUnknownKeyThrowsIllegalArgumentException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("MyBeanKey", mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).hasSize(1);
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory for key [UnknownKey] was not found");
try {
GemfireBeanFactoryLocator.resolveBeanFactory("UnknownKey");
}
catch (IllegalArgumentException expected) {
GemfireBeanFactoryLocator.resolveBeanFactory("UnknownKey");
assertThat(expected).hasMessage("BeanFactory for key [UnknownKey] was not found");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void resolveSingleBeanFactoryWithNoRegisteredBeanFactoriesReturnsNull() {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.isEmpty()).isTrue();
assertThat(GemfireBeanFactoryLocator.resolveSingleBeanFactory()).isNull();
}
@Test
public void resolveSingleBeanFactoryWhenSingleBeanFactoryIsRegisteredReturnsSingleBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("MyBeanKey", mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.size()).isEqualTo(1);
@@ -169,6 +180,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void resolveSingleBeanFactoryWhenMultipleIdenticalBeanFactoriesAreRegisteredReturnsSingleBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refTwo", mockBeanFactory);
@@ -176,23 +188,31 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(GemfireBeanFactoryLocator.resolveSingleBeanFactory()).isSameAs(mockBeanFactory);
}
@Test
@Test(expected = IllegalStateException.class)
public void resolveSingeBeanFactoryWhenMultipleDifferentBeanFactoriesAreRegisteredThrowsIllegalStateException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refTwo", mock(BeanFactory.class));
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.size()).isEqualTo(2);
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory key must be specified when more than one BeanFactory [refOne, refTwo]"
+ " is registered");
try {
GemfireBeanFactoryLocator.resolveSingleBeanFactory();
}
catch (IllegalStateException expected) {
GemfireBeanFactoryLocator.resolveSingleBeanFactory();
assertThat(expected)
.hasMessage("BeanFactory key must be specified when more than one BeanFactory [refOne, refTwo] is registered");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void registerAliasesIsSuccessful() {
Set<String> aliases = asSet("aliasOne", "aliasTwo", "aliasThree");
GemfireBeanFactoryLocator.registerAliases(aliases, mockBeanFactory);
@@ -208,6 +228,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void registerAliasesWithEmptyAliasesAndNonNullBeanFactoryDoesNothing() {
GemfireBeanFactoryLocator.registerAliases(Collections.emptySet(), mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.isEmpty()).isTrue();
@@ -215,22 +236,30 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void registerAliasesWithEmptyAliasesAndNullBeanFactoryDoesNothing() {
GemfireBeanFactoryLocator.registerAliases(Collections.emptySet(), null);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.isEmpty()).isTrue();
}
@Test
@Test(expected = IllegalArgumentException.class)
public void registerAliasesWithNonEmptyAliasesAndNullBeanFactoryThrowsIllegalArgumentException() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory must not be null when aliases are specified");
GemfireBeanFactoryLocator.registerAliases(asSet("aliasOne", "aliasTwo"), null);
try {
GemfireBeanFactoryLocator.registerAliases(asSet("aliasOne", "aliasTwo"), null);
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("BeanFactory must not be null when aliases are specified");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void registerAliasesWithNullAliasesHandlesNullAndDoesNothing() {
GemfireBeanFactoryLocator.registerAliases(null, null);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.isEmpty()).isTrue();
@@ -238,6 +267,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void registerAliasesWhenIdenticalBeanFactoryReferencesAlreadyExistIsSuccessful() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasTwo", mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.size()).isEqualTo(1);
@@ -250,22 +280,29 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.get("aliasTwo")).isSameAs(mockBeanFactory);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void registerAliasesWhenNonIdenticalBeanFactoryReferencesAlreadyExistThrowsIllegalArgumentException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasTwo", mockBeanFactory);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.size()).isEqualTo(1);
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.get("aliasTwo")).isSameAs(mockBeanFactory);
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory reference already exists for key [aliasTwo]");
try {
GemfireBeanFactoryLocator.registerAliases(asSet("aliasOne", "aliasTwo"), mock(BeanFactory.class));
}
catch (IllegalArgumentException expected) {
GemfireBeanFactoryLocator.registerAliases(asSet("aliasOne", "aliasTwo"), mock(BeanFactory.class));
assertThat(expected).hasMessage("BeanFactory reference already exists for key [aliasTwo]");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void unregisterAliasesRemovesAll() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasTwo", mockBeanFactory);
@@ -278,6 +315,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void unregisterAliasesRemovesPartial() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasTwo", mockBeanFactory);
@@ -292,6 +330,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void unregisterAliasesRemovesNone() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("aliasTwo", mockBeanFactory);
@@ -306,6 +345,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void afterPropertiesSetResolvesAndInitializesBeanNamesWithAliasesThenRegisterAliases() {
when(mockBeanFactory.getAliases(eq("AssociatedBeanName"))).thenReturn(new String[] { "aliasOne", "aliasTwo" });
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator(mockBeanFactory, "AssociatedBeanName");
@@ -330,6 +370,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void afterPropertiesSetUnableToResolveInitializeAndRegisterAliasesWithNullBeanFactory() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator(null, "AssociatedBeanName");
assertThat(beanFactoryLocator).isNotNull();
@@ -342,6 +383,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void destroyUnregistersOwningAliases() {
BeanFactory mockBeanFactoryTwo = mock(BeanFactory.class, "MockBeanFactoryTwo");
when(mockBeanFactory.getAliases(eq("AssociatedBeanName"))).thenReturn(new String[] { "aliasOne", "aliasTwo" });
@@ -372,20 +414,27 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.keySet()).containsAll(asSet("refOne", "refTwo"));
verify(mockBeanFactory, times(1)).getAliases(eq("AssociatedBeanName"));
verifyZeroInteractions(mockBeanFactoryTwo);
verifyNoMoreInteractions(mockBeanFactoryTwo);
}
@Test
@Test(expected = IllegalStateException.class)
public void useBeanFactoryWhenNoBeanFactoriesAreRegisteredThrowsIllegalStateException() {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(UNINITIALIZED_BEAN_FACTORY_REFERENCE_MESSAGE);
newBeanFactoryLocator().useBeanFactory();
try {
newBeanFactoryLocator().useBeanFactory();
}
catch (IllegalStateException expected) {
assertThat(expected).hasMessage(UNINITIALIZED_BEAN_FACTORY_REFERENCE_MESSAGE);
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void useBeanFactoryWhenSingleBeanFactoryIsRegisteredReturnsSingleBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refTwo", mockBeanFactory);
@@ -394,23 +443,31 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(newBeanFactoryLocator().useBeanFactory()).isSameAs(mockBeanFactory);
}
@Test
@Test(expected = IllegalStateException.class)
public void useBeanFactoryWhenMultipleBeanFactoriesAreRegisteredThrowsIllegalStateException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refTwo", mock(BeanFactory.class, "MockBeanFactoryTwo"));
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES).hasSize(2);
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory key must be specified when more than one BeanFactory [refOne, refTwo]"
+ " is registered");
try {
newBeanFactoryLocator().useBeanFactory();
}
catch (IllegalStateException expected) {
newBeanFactoryLocator().useBeanFactory();
assertThat(expected)
.hasMessage("BeanFactory key must be specified when more than one BeanFactory [refOne, refTwo] is registered");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void useBeanFactoryWhenMultipleBeanFactoriesAreRegisteredWithConfiguredKeyReturnsBeanFactory() {
BeanFactory mockBeanFactoryTwo = mock(BeanFactory.class, "MockBeanFactoryTwo");
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("refOne", mockBeanFactory);
@@ -423,6 +480,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void useBeanFactoryWithKeyReturnsSpecificBeanFactory() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyTwo", mock(BeanFactory.class, "MockBeanFactoryTwo"));
@@ -430,22 +488,29 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(newBeanFactoryLocator().useBeanFactory("keyOne")).isSameAs(mockBeanFactory);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void useBeanFactoryWithUnknownKeyThrowsIllegalArgumentException() {
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyOne", mockBeanFactory);
GemfireBeanFactoryLocator.BEAN_FACTORIES.put("keyTwo", mock(BeanFactory.class, "MockBeanFactoryTwo"));
assertThat(GemfireBeanFactoryLocator.BEAN_FACTORIES.size()).isEqualTo(2);
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("BeanFactory for key [UnknownKey] was not found");
try {
newBeanFactoryLocator().useBeanFactory("UnknownKey");
}
catch (IllegalArgumentException expected) {
newBeanFactoryLocator().useBeanFactory("UnknownKey");
assertThat(expected).hasMessage("BeanFactory for key [UnknownKey] was not found");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
public void setAndGetBeanFactory() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator();
assertThat(beanFactoryLocator).isNotNull();
@@ -459,11 +524,12 @@ public class GemfireBeanFactoryLocatorUnitTests {
assertThat(beanFactoryLocator.getBeanFactory()).isNull();
verifyZeroInteractions(mockBeanFactory);
verifyNoInteractions(mockBeanFactory);
}
@Test
public void setAndGetAssociatedBeanName() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator(null, "AssociatedBeanName");
assertThat(beanFactoryLocator).isNotNull();
@@ -486,6 +552,7 @@ public class GemfireBeanFactoryLocatorUnitTests {
@Test
public void withBeanNameIsSuccessful() {
GemfireBeanFactoryLocator beanFactoryLocator = newBeanFactoryLocator();
assertThat(beanFactoryLocator).isNotNull();

198
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/LazyWiringDeclarableSupportUnitTests.java
View File

@@ -14,17 +14,10 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.anyString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -35,9 +28,7 @@ import java.util.Properties;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
@@ -46,7 +37,7 @@ import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.ContextRefreshedEvent;
/**
* Unit tests for {@link LazyWiringDeclarableSupport}.
* Unit Tests for {@link LazyWiringDeclarableSupport}.
*
* @author John Blum
* @see org.junit.Rule
@@ -59,25 +50,29 @@ import org.springframework.context.event.ContextRefreshedEvent;
*/
public class LazyWiringDeclarableSupportUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private static void assertParameters(Properties parameters, String expectedKey, String expectedValue) {
assertThat(parameters, is(notNullValue()));
assertThat(parameters.containsKey(expectedKey), is(true));
assertThat(parameters.getProperty(expectedKey), is(equalTo(expectedValue)));
assertThat(parameters).isNotNull();
assertThat(parameters.containsKey(expectedKey)).isTrue();
assertThat(parameters.getProperty(expectedKey)).isEqualTo(expectedValue);
}
private static Properties createParameters(String parameter, String value) {
Properties parameters = new Properties();
parameters.setProperty(parameter, value);
return parameters;
}
@Test
public void assertInitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected boolean isInitialized() {
@Override
protected boolean isInitialized() {
return true;
}
};
@@ -90,23 +85,30 @@ public class LazyWiringDeclarableSupportUnitTests {
}
}
@Test
@Test(expected = IllegalStateException.class)
public void assertInitializedWhenUninitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected boolean isInitialized() {
@Override
protected boolean isInitialized() {
return false;
}
};
try {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(String.format(
"This Declarable object [%s] has not been properly configured and initialized",
declarable.getClass().getName()));
declarable.assertInitialized();
}
catch (IllegalStateException expected) {
assertThat(expected)
.hasMessage("This Declarable object [%s] has not been properly configured and initialized",
declarable.getClass().getName());
assertThat(expected).hasNoCause();
throw expected;
}
finally {
SpringContextBootstrappingInitializer.unregister(declarable);
}
@@ -114,6 +116,7 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void assertUninitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport();
try {
@@ -124,9 +127,11 @@ public class LazyWiringDeclarableSupportUnitTests {
}
}
@Test
@Test(expected = IllegalStateException.class)
public void assertUninitializedWhenInitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override
protected boolean isInitialized() {
return true;
@@ -134,14 +139,18 @@ public class LazyWiringDeclarableSupportUnitTests {
};
try {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage(String.format(
"This Declarable object [%s] has already been configured and initialized",
declarable.getClass().getName()));
declarable.assertUninitialized();
}
catch (IllegalStateException expected) {
assertThat(expected)
.hasMessage("This Declarable object [%s] has already been configured and initialized",
declarable.getClass().getName());
assertThat(expected).hasNoCause();
throw expected;
}
finally {
SpringContextBootstrappingInitializer.unregister(declarable);
}
@@ -149,10 +158,11 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void init() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport();
try {
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.isInitialized()).isFalse();
declarable.init(createParameters("param", "value"));
@@ -161,7 +171,7 @@ public class LazyWiringDeclarableSupportUnitTests {
declarable.init(createParameters("newParam", "newValue"));
assertParameters(declarable.nullSafeGetParameters(), "newParam", "newValue");
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.isInitialized()).isFalse();
}
finally {
SpringContextBootstrappingInitializer.unregister(declarable);
@@ -170,30 +180,37 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void isInitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected boolean isInitialized() {
@Override
protected boolean isInitialized() {
return true;
}
};
assertThat(declarable.isInitialized(), is(true));
assertThat(declarable.isNotInitialized(), is(false));
assertThat(declarable.isInitialized()).isTrue();
assertThat(declarable.isNotInitialized()).isFalse();
}
@Test
public void isUninitialized() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected boolean isInitialized() {
@Override
protected boolean isInitialized() {
return false;
}
};
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.isNotInitialized(), is(true));
assertThat(declarable.isInitialized()).isFalse();
assertThat(declarable.isNotInitialized()).isTrue();
}
@Test
public void nullSafeGetParametersWithNullReference() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport();
try {
@@ -201,8 +218,8 @@ public class LazyWiringDeclarableSupportUnitTests {
Properties parameters = declarable.nullSafeGetParameters();
assertThat(parameters, is(notNullValue()));
assertThat(parameters.isEmpty(), is(true));
assertThat(parameters).isNotNull();
assertThat(parameters.isEmpty()).isTrue();
}
finally {
SpringContextBootstrappingInitializer.unregister(declarable);
@@ -211,6 +228,7 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void onApplicationEvent() {
ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class);
ConfigurableListableBeanFactory mockBeanFactory = mock(ConfigurableListableBeanFactory.class);
@@ -219,7 +237,9 @@ public class LazyWiringDeclarableSupportUnitTests {
final AtomicBoolean doPostInitCalled = new AtomicBoolean(false);
TestLazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected void doPostInit(final Properties parameters) {
@Override
protected void doPostInit(final Properties parameters) {
super.doPostInit(parameters);
assertInitialized();
LazyWiringDeclarableSupportUnitTests.assertParameters(parameters, "param", "value");
@@ -235,8 +255,8 @@ public class LazyWiringDeclarableSupportUnitTests {
declarable.assertBeanFactory(mockBeanFactory);
declarable.assertParameters(parameters);
assertThat(declarable.isInitialized(), is(true));
assertThat(doPostInitCalled.get(), is(true));
assertThat(declarable.isInitialized()).isTrue();
assertThat(doPostInitCalled.get()).isTrue();
verify(mockApplicationContext, times(1)).getBeanFactory();
}
@@ -245,8 +265,9 @@ public class LazyWiringDeclarableSupportUnitTests {
}
}
@Test
public void onApplicationEventWithNullApplicationContext() throws Throwable {
@Test(expected = IllegalArgumentException.class)
public void onApplicationEventWithNullApplicationContext() {
LazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport();
try {
@@ -254,14 +275,19 @@ public class LazyWiringDeclarableSupportUnitTests {
when(mockContextRefreshedEvent.getApplicationContext()).thenReturn(null);
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("The Spring ApplicationContext [null] must be an instance of ConfigurableApplicationContext");
declarable.onApplicationEvent(mockContextRefreshedEvent);
}
catch (IllegalArgumentException expected) {
assertThat(expected)
.hasMessage("The Spring ApplicationContext [null] must be an instance of ConfigurableApplicationContext");
assertThat(expected).hasNoCause();
throw expected;
}
catch (Throwable t) {
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.isInitialized()).isFalse();
throw t;
}
finally {
@@ -271,6 +297,7 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void fullLifecycleOnApplicationEventToDestroy() throws Exception {
ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class);
ConfigurableListableBeanFactory mockBeanFactory = mock(ConfigurableListableBeanFactory.class);
@@ -279,7 +306,9 @@ public class LazyWiringDeclarableSupportUnitTests {
final AtomicBoolean doPostInitCalled = new AtomicBoolean(false);
TestLazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected void doPostInit(final Properties parameters) {
@Override
protected void doPostInit(final Properties parameters) {
super.doPostInit(parameters);
assertInitialized();
LazyWiringDeclarableSupportUnitTests.assertParameters(parameters, "param", "value");
@@ -294,29 +323,29 @@ public class LazyWiringDeclarableSupportUnitTests {
try {
declarable.init(parameters);
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.nullSafeGetParameters(), is(sameInstance(parameters)));
assertThat(doPostInitCalled.get(), is(false));
assertThat(declarable.isInitialized()).isFalse();
assertThat(declarable.nullSafeGetParameters()).isSameAs(parameters);
assertThat(doPostInitCalled.get()).isFalse();
initializer.onApplicationEvent(new ContextRefreshedEvent(mockApplicationContext));
assertThat(declarable.isInitialized(), is(true));
assertThat(doPostInitCalled.get(), is(true));
assertThat(declarable.isInitialized()).isTrue();
assertThat(doPostInitCalled.get()).isTrue();
declarable.assertBeanFactory(mockBeanFactory);
declarable.assertParameters(parameters);
doPostInitCalled.set(false);
declarable.destroy();
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.nullSafeGetParameters(), is(not(sameInstance(parameters))));
assertThat(doPostInitCalled.get(), is(false));
assertThat(declarable.isInitialized()).isFalse();
assertThat(declarable.nullSafeGetParameters()).isNotSameAs(parameters);
assertThat(doPostInitCalled.get()).isFalse();
initializer.onApplicationEvent(new ContextRefreshedEvent(mockApplicationContext));
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.nullSafeGetParameters(), is(not(sameInstance(parameters))));
assertThat(doPostInitCalled.get(), is(false));
assertThat(declarable.isInitialized()).isFalse();
assertThat(declarable.nullSafeGetParameters()).isNotSameAs(parameters);
assertThat(doPostInitCalled.get()).isFalse();
verify(mockApplicationContext, times(1)).getBeanFactory();
}
@@ -327,6 +356,7 @@ public class LazyWiringDeclarableSupportUnitTests {
@Test
public void initThenOnApplicationEventThenInitWhenInitialized() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class);
@@ -344,7 +374,9 @@ public class LazyWiringDeclarableSupportUnitTests {
final AtomicReference<String> expectedValue = new AtomicReference<>("testValue");
TestLazyWiringDeclarableSupport declarable = new TestLazyWiringDeclarableSupport() {
@Override protected void doPostInit(final Properties parameters) {
@Override
protected void doPostInit(final Properties parameters) {
super.doPostInit(parameters);
assertInitialized();
LazyWiringDeclarableSupportUnitTests.assertParameters(parameters, expectedKey.get(), expectedValue.get());
@@ -357,26 +389,26 @@ public class LazyWiringDeclarableSupportUnitTests {
try {
locator.afterPropertiesSet();
assertThat(declarable.isInitialized(), is(false));
assertThat(declarable.nullSafeGetParameters(), is(not(sameInstance(parameters))));
assertThat(doPostInitCalled.get(), is(false));
assertThat(declarable.isInitialized()).isFalse();
assertThat(declarable.nullSafeGetParameters()).isNotSameAs(parameters);
assertThat(doPostInitCalled.get()).isFalse();
declarable.init(parameters);
declarable.assertBeanFactory(mockBeanFactory);
declarable.assertParameters(parameters);
assertThat(declarable.isInitialized(), is(true));
assertThat(declarable.nullSafeGetParameters(), is(sameInstance(parameters)));
assertThat(doPostInitCalled.get(), is(true));
assertThat(declarable.isInitialized()).isTrue();
assertThat(declarable.nullSafeGetParameters()).isSameAs(parameters);
assertThat(doPostInitCalled.get()).isTrue();
doPostInitCalled.set(false);
declarable.onApplicationEvent(new ContextRefreshedEvent(mockApplicationContext));
declarable.assertBeanFactory(mockConfigurableListableBeanFactory);
declarable.assertParameters(parameters);
assertThat(declarable.isInitialized(), is(true));
assertThat(declarable.nullSafeGetParameters(), is(sameInstance(parameters)));
assertThat(doPostInitCalled.get(), is(true));
assertThat(declarable.isInitialized()).isTrue();
assertThat(declarable.nullSafeGetParameters()).isSameAs(parameters);
assertThat(doPostInitCalled.get()).isTrue();
doPostInitCalled.set(false);
expectedKey.set("mockKey");
@@ -387,9 +419,9 @@ public class LazyWiringDeclarableSupportUnitTests {
declarable.assertBeanFactory(mockBeanFactory);
declarable.assertParameters(parameters);
assertThat(declarable.isInitialized(), is(true));
assertThat(declarable.nullSafeGetParameters(), is(sameInstance(parameters)));
assertThat(doPostInitCalled.get(), is(true));
assertThat(declarable.isInitialized()).isTrue();
assertThat(declarable.nullSafeGetParameters()).isSameAs(parameters);
assertThat(doPostInitCalled.get()).isTrue();
verify(mockApplicationContext, times(1)).getBeanFactory();
}
@@ -403,12 +435,12 @@ public class LazyWiringDeclarableSupportUnitTests {
private BeanFactory actualBeanFactory;
private Properties actualParameters;
private void assertBeanFactory(final BeanFactory expectedBeanFactory) {
assertThat(this.actualBeanFactory, is(sameInstance(expectedBeanFactory)));
private void assertBeanFactory(BeanFactory expectedBeanFactory) {
assertThat(this.actualBeanFactory).isSameAs(expectedBeanFactory);
}
private void assertParameters(final Properties expectedParameters) {
assertThat(this.actualParameters, is(equalTo(expectedParameters)));
private void assertParameters(Properties expectedParameters) {
assertThat(this.actualParameters).isEqualTo(expectedParameters);
}
@Override

31
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderIntegrationTest.java → spring-data-geode/src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderIntegrationTests.java
View File

@@ -15,25 +15,21 @@
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.Cache;
import org.apache.geode.distributed.AbstractLauncher.Status;
import org.apache.geode.distributed.ServerLauncher;
import org.apache.geode.distributed.ServerLauncher.ServerState;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.gemfire.GemfireUtils;
/**
* The SpringServerLauncherCacheProviderTest class is a test suite of test cases testing the contract and functionality
* of the {@link SpringServerLauncherCacheProvider} class.
* Integration Tests {@link SpringServerLauncherCacheProvider} class.
*
* This test class focuses on testing isolated units of functionality in the
* {@link org.apache.geode.distributed.ServerLauncherCacheProvider} class directly, mocking any dependencies
@@ -42,13 +38,13 @@ import org.springframework.data.gemfire.GemfireUtils;
* @author Dan Smith
* @author John Blum
* @see org.junit.Test
* @see org.apache.geode.cache.Cache
* @see org.apache.geode.distributed.ServerLauncher
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
* @see org.apache.geode.cache.Cache
* @see org.apache.geode.distributed.ServerLauncher
*/
public class SpringServerLauncherCacheProviderIntegrationTest {
public class SpringServerLauncherCacheProviderIntegrationTests {
@After
public void tearDown() {
@@ -58,7 +54,7 @@ public class SpringServerLauncherCacheProviderIntegrationTest {
GemfireUtils.closeClientCache();
}
String gemfireName() {
private String gemfireName() {
return GemfireUtils.GEMFIRE_PREFIX + GemfireUtils.NAME_PROPERTY_NAME;
}
@@ -77,19 +73,18 @@ public class SpringServerLauncherCacheProviderIntegrationTest {
ServerState state = launcher.start();
assertThat(state.getStatus(), is(equalTo(Status.ONLINE)));
assertThat(state.getStatus()).isEqualTo(Status.ONLINE);
ConfigurableApplicationContext applicationContext =
SpringContextBootstrappingInitializer.getApplicationContext();
Cache cache = applicationContext.getBean(Cache.class);
assertThat(cache, is(notNullValue()));
assertThat(cache.getResourceManager().getCriticalHeapPercentage(), is(equalTo(55.0f)));
assertThat(cache).isNotNull();
assertThat(cache.getResourceManager().getCriticalHeapPercentage()).isEqualTo(55.0f);
state = launcher.stop();
assertThat(state.getStatus(), is(equalTo(Status.STOPPED)));
assertThat(state.getStatus()).isEqualTo(Status.STOPPED);
}
}

42
spring-data-geode/src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderTest.java → spring-data-geode/src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderUnitTests.java
View File

@@ -15,11 +15,8 @@
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.eq;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -27,39 +24,40 @@ import static org.mockito.Mockito.when;
import java.util.Properties;
import org.apache.geode.cache.Cache;
import org.apache.geode.distributed.ServerLauncher;
import org.junit.After;
import org.junit.Test;
import org.apache.geode.cache.Cache;
import org.apache.geode.distributed.ServerLauncher;
import org.apache.geode.distributed.ServerLauncherCacheProvider;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.gemfire.GemfireUtils;
/**
* The SpringServerLauncherCacheProviderTest class is a test suite of test cases testing the contract and functionality
* of the {@link SpringServerLauncherCacheProvider} class. This test class focuses on testing isolated units
* of functionality in the {@link org.apache.geode.distributed.ServerLauncherCacheProvider} class directly, mocking
* any dependencies as appropriate, in order for the class to uphold it's contract.
* Unit Tests testing the contract and functionality of the {@link SpringServerLauncherCacheProvider} class.
*
* This test class focuses on testing isolated units of functionality in the {@link ServerLauncherCacheProvider} class
* directly, mocking any dependencies as appropriate, in order for the class to uphold it's contract.
*
* @author Dan Smith
* @author John Blum
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
* @see org.apache.geode.cache.Cache
* @see org.apache.geode.distributed.ServerLauncher
* @see org.apache.geode.distributed.ServerLauncherCacheProvider
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
*/
public class SpringServerLauncherCacheProviderTest {
public class SpringServerLauncherCacheProviderUnitTests {
String gemfireName() {
private String gemfireName() {
return (GemfireUtils.GEMFIRE_PREFIX + GemfireUtils.NAME_PROPERTY_NAME);
}
Properties singletonProperties(String propertyName, String propertyValue) {
private Properties singletonProperties(String propertyName, String propertyValue) {
Properties properties = new Properties();
properties.setProperty(propertyName, propertyValue);
return properties;
@@ -73,6 +71,7 @@ public class SpringServerLauncherCacheProviderTest {
@Test
public void createsCacheWhenSpringXmlLocationIsSpecified() {
Cache mockCache = mock(Cache.class);
ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class);
ServerLauncher mockServerLauncher = mock(ServerLauncher.class);
@@ -87,6 +86,7 @@ public class SpringServerLauncherCacheProviderTest {
final SpringContextBootstrappingInitializer initializer = mock(SpringContextBootstrappingInitializer.class);
SpringServerLauncherCacheProvider provider = new SpringServerLauncherCacheProvider() {
@Override
public SpringContextBootstrappingInitializer newSpringContextBootstrappingInitializer() {
return initializer;
@@ -96,7 +96,7 @@ public class SpringServerLauncherCacheProviderTest {
Properties expectedParameters = singletonProperties(
SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER, "test-context.xml");
assertThat(provider.createCache(null, mockServerLauncher), is(equalTo(mockCache)));
assertThat(provider.createCache(null, mockServerLauncher)).isEqualTo(mockCache);
verify(mockServerLauncher, times(1)).isSpringXmlLocationSpecified();
verify(mockServerLauncher, times(1)).getSpringXmlLocation();
@@ -107,13 +107,13 @@ public class SpringServerLauncherCacheProviderTest {
@Test
public void doesNothingWhenSpringXmlLocationNotSpecified() {
ServerLauncher launcher = mock(ServerLauncher.class);
when(launcher.isSpringXmlLocationSpecified()).thenReturn(false);
assertThat(new SpringServerLauncherCacheProvider().createCache(null, launcher), is(nullValue()));
assertThat(new SpringServerLauncherCacheProvider().createCache(null, launcher)).isNull();
verify(launcher, times(1)).isSpringXmlLocationSpecified();
}
}

188
spring-data-geode/src/test/java/org/springframework/data/gemfire/util/PropertiesBuilderTests.java
View File

@@ -14,15 +14,9 @@
* limitations under the License.
*
*/
package org.springframework.data.gemfire.util;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@@ -43,53 +37,56 @@ import org.junit.Test;
*/
public class PropertiesBuilderTests {
protected Properties singletonProperties(String name, String value) {
private Properties singletonProperties(String name, String value) {
Properties properties = new Properties();
properties.setProperty(name, value);
return properties;
}
@Test
@SuppressWarnings("unchecked")
public void constructDefaultPropertiesBuilder() throws Exception {
PropertiesBuilder builder = new PropertiesBuilder();
Properties properties = builder.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(builder.getObject(), is(sameInstance(properties)));
assertThat((Class<Properties>) builder.getObjectType(), is(equalTo(Properties.class)));
assertThat(properties.isEmpty(), is(true));
assertThat(properties).isNotNull();
assertThat(builder.getObject()).isSameAs(properties);
assertThat(builder.getObjectType()).isEqualTo(Properties.class);
assertThat(properties.isEmpty()).isTrue();
}
@Test
public void constructPropertiesBuilderWithDefaultProperties() {
Properties defaults = singletonProperties("one", "1");
PropertiesBuilder builder = new PropertiesBuilder(defaults);
Properties properties = builder.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties, is(not(sameInstance(defaults))));
assertThat(properties, is(equalTo(defaults)));
assertThat(properties).isNotNull();
assertThat(properties).isNotSameAs(defaults);
assertThat(properties).isEqualTo(defaults);
}
@Test
public void constructPropertiesBuilderWithPropertiesBuilder() {
PropertiesBuilder defaults = new PropertiesBuilder().setProperty("one", "1");
PropertiesBuilder builder = new PropertiesBuilder(defaults);
Properties properties = builder.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(1)));
assertThat(properties.containsKey("one"), is(true));
assertThat(properties.getProperty("one"), is(equalTo("1")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(1);
assertThat(properties.containsKey("one")).isTrue();
assertThat(properties.getProperty("one")).isEqualTo("1");
}
@Test
public void fromInputStreamIsSuccessful() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
Properties source = singletonProperties("one", "1");
@@ -98,13 +95,14 @@ public class PropertiesBuilderTests {
Properties sink = PropertiesBuilder.from(new ByteArrayInputStream(out.toByteArray())).build();
assertThat(sink, is(notNullValue(Properties.class)));
assertThat(sink, is(not(sameInstance(source))));
assertThat(sink, is(equalTo(source)));
assertThat(sink).isNotNull();
assertThat(sink).isNotSameAs(source);
assertThat(sink).isEqualTo(source);
}
@Test
public void fromReaderIsSuccessful() throws IOException {
StringWriter writer = new StringWriter();
Properties source = singletonProperties("one", "1");
@@ -113,13 +111,14 @@ public class PropertiesBuilderTests {
Properties sink = PropertiesBuilder.from(new StringReader(writer.toString())).build();
assertThat(sink, is(notNullValue(Properties.class)));
assertThat(sink, is(not(sameInstance(source))));
assertThat(sink, is(equalTo(source)));
assertThat(sink).isNotNull();
assertThat(sink).isNotSameAs(source);
assertThat(sink).isEqualTo(source);
}
@Test
public void fromXmlInputStreamIsSuccessful() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
Properties source = singletonProperties("one", "1");
@@ -128,37 +127,37 @@ public class PropertiesBuilderTests {
Properties sink = PropertiesBuilder.fromXml(new ByteArrayInputStream(out.toByteArray())).build();
assertThat(sink, is(notNullValue(Properties.class)));
assertThat(sink, is(not(sameInstance(source))));
assertThat(sink, is(equalTo(source)));
assertThat(sink).isNotNull();
assertThat(sink).isNotSameAs(source);
assertThat(sink).isEqualTo(source);
}
@Test
@SuppressWarnings("unchecked")
public void propertiesBuilderObjectTypeIsPropertiesClass() {
assertThat((Class<Properties>) PropertiesBuilder.create().getObjectType(), is(equalTo(Properties.class)));
assertThat(PropertiesBuilder.create().getObjectType()).isEqualTo(Properties.class);
}
@Test
public void propertiesBuilderIsSingletonIsTrue() {
assertThat(new PropertiesBuilder().isSingleton(), is(true));
assertThat(new PropertiesBuilder().isSingleton()).isTrue();
}
@Test
public void addPropertiesFromPropertiesIsSuccessful() {
PropertiesBuilder builder = PropertiesBuilder.create()
.setProperty("one", "1")
.setProperty("two", "@");
Properties sink = builder.build();
assertThat(sink, is(notNullValue(Properties.class)));
assertThat(sink.size(), is(2));
assertThat(sink.containsKey("one"), is(true));
assertThat(sink.containsKey("two"), is(true));
assertThat(sink.containsKey("three"), is(false));
assertThat(sink.getProperty("one"), is(equalTo("1")));
assertThat(sink.getProperty("two"), is(equalTo("@")));
assertThat(sink).isNotNull();
assertThat(sink.size()).isEqualTo(2);
assertThat(sink.containsKey("one")).isTrue();
assertThat(sink.containsKey("two")).isTrue();
assertThat(sink.containsKey("three")).isFalse();
assertThat(sink.getProperty("one")).isEqualTo("1");
assertThat(sink.getProperty("two")).isEqualTo("@");
Properties source = new Properties();
@@ -169,35 +168,37 @@ public class PropertiesBuilderTests {
sink = builder.build();
assertThat(sink, is(notNullValue(Properties.class)));
assertThat(sink.size(), is(equalTo(3)));
assertThat(sink, is(not(sameInstance(source))));
assertThat(sink.containsKey("one"), is(true));
assertThat(sink.containsKey("two"), is(true));
assertThat(sink.containsKey("three"), is(true));
assertThat(sink.getProperty("one"), is(equalTo("1")));
assertThat(sink.getProperty("two"), is(equalTo("2")));
assertThat(sink.getProperty("three"), is(equalTo("3")));
assertThat(sink).isNotNull();
assertThat(sink.size()).isEqualTo(3);
assertThat(sink).isNotSameAs(source);
assertThat(sink.containsKey("one")).isTrue();
assertThat(sink.containsKey("two")).isTrue();
assertThat(sink.containsKey("three")).isTrue();
assertThat(sink.getProperty("one")).isEqualTo("1");
assertThat(sink.getProperty("two")).isEqualTo("2");
assertThat(sink.getProperty("three")).isEqualTo("3");
}
@Test
public void addPropertiesFromPropertiesBuilderIsSuccessful() {
PropertiesBuilder source = PropertiesBuilder.create()
.setProperty("one", "1")
.setProperty("two", "2");
Properties properties = PropertiesBuilder.create().add(source).build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(2)));
assertThat(properties.containsKey("one"), is(true));
assertThat(properties.containsKey("two"), is(true));
assertThat(properties.getProperty("one"), is(equalTo("1")));
assertThat(properties.getProperty("two"), is(equalTo("2")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(2);
assertThat(properties.containsKey("one")).isTrue();
assertThat(properties.containsKey("two")).isTrue();
assertThat(properties.getProperty("one")).isEqualTo("1");
assertThat(properties.getProperty("two")).isEqualTo("2");
}
@Test
public void setObjectPropertyValuesIsSuccessful() {
Properties properties = PropertiesBuilder.create()
.setProperty("boolean", Boolean.TRUE)
.setProperty("character", 'A')
@@ -206,37 +207,40 @@ public class PropertiesBuilderTests {
.setProperty("string", (Object) "test")
.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(5)));
assertThat(properties.getProperty("boolean"), is(equalTo(Boolean.TRUE.toString())));
assertThat(properties.getProperty("character"), is(equalTo("A")));
assertThat(properties.getProperty("integer"), is(equalTo("1")));
assertThat(properties.getProperty("double"), is(equalTo(String.valueOf(Math.PI))));
assertThat(properties.getProperty("string"), is(equalTo("test")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(5);
assertThat(properties.getProperty("boolean")).isEqualTo(Boolean.TRUE.toString());
assertThat(properties.getProperty("character")).isEqualTo("A");
assertThat(properties.getProperty("integer")).isEqualTo("1");
assertThat(properties.getProperty("double")).isEqualTo(String.valueOf(Math.PI));
assertThat(properties.getProperty("string")).isEqualTo("test");
}
@Test
public void setObjectArrayPropertyValueIsSuccessful() {
Properties properties = PropertiesBuilder.create()
.setProperty("numbers", new Object[] { "one", "two", "three" })
.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(1)));
assertThat(properties.containsKey("numbers"), is(true));
assertThat(properties.getProperty("numbers"), is(equalTo("one,two,three")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(1);
assertThat(properties.containsKey("numbers")).isTrue();
assertThat(properties.getProperty("numbers")).isEqualTo("one,two,three");
}
@Test
public void setPropertyIgnoresNullObjectValue() {
Properties properties = PropertiesBuilder.create().setProperty("object", (Object) null).build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.isEmpty(), is(true));
assertThat(properties).isNotNull();
assertThat(properties.isEmpty()).isTrue();
}
@Test
public void setPropertyIgnoresEmptyAndNullLiteralStringValues() {
Properties properties = PropertiesBuilder.create()
.setProperty("blank", " ")
.setProperty("empty", "")
@@ -244,66 +248,72 @@ public class PropertiesBuilderTests {
.setProperty("nullWithWhiteSpace", " null ")
.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.isEmpty(), is(true));
assertThat(properties).isNotNull();
assertThat(properties.isEmpty()).isTrue();
}
@Test
public void setPropertyIgnoresEmptyObjectArray() {
Properties properties = PropertiesBuilder.create().setProperty("emptyArray", new Object[0]).build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.isEmpty(), is(true));
assertThat(properties).isNotNull();
assertThat(properties.isEmpty()).isTrue();
}
@Test
public void setPropertyIgnoresNullObjectArray() {
Properties properties = PropertiesBuilder.create().setProperty("nullArray", (Object[]) null).build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.isEmpty(), is(true));
assertThat(properties).isNotNull();
assertThat(properties.isEmpty()).isTrue();
}
@Test
public void setStringPropertyValuesIsSuccessful() {
Properties properties = PropertiesBuilder.create()
.setProperty("one", "1")
.setProperty("two", "2")
.build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(2)));
assertThat(properties.containsKey("one"), is(true));
assertThat(properties.containsKey("two"), is(true));
assertThat(properties.getProperty("one"), is(equalTo("1")));
assertThat(properties.getProperty("two"), is(equalTo("2")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(2);
assertThat(properties.containsKey("one")).isTrue();
assertThat(properties.containsKey("two")).isTrue();
assertThat(properties.getProperty("one")).isEqualTo("1");
assertThat(properties.getProperty("two")).isEqualTo("2");
}
@Test
public void unsetPropertyIsSuccessful() {
Properties properties = PropertiesBuilder.create().unsetProperty("example").build();
assertThat(properties, is(notNullValue(Properties.class)));
assertThat(properties.size(), is(equalTo(1)));
assertThat(properties.containsKey("example"), is(true));
assertThat(properties.getProperty("example"), is(equalTo("")));
assertThat(properties).isNotNull();
assertThat(properties.size()).isEqualTo(1);
assertThat(properties.containsKey("example")).isTrue();
assertThat(properties.getProperty("example")).isEqualTo("");
}
@Test
public void stringLiteralIsValuable() {
assertThat(PropertiesBuilder.create().isValuable("test"), is(true));
assertThat(PropertiesBuilder.create().isValuable("test")).isTrue();
}
@Test
public void nullStringLiteralIsNotValuable() {
assertThat(PropertiesBuilder.create().isValuable("null"), is(false));
assertThat(PropertiesBuilder.create().isValuable("Null"), is(false));
assertThat(PropertiesBuilder.create().isValuable("NULL"), is(false));
assertThat(PropertiesBuilder.create().isValuable("null")).isFalse();
assertThat(PropertiesBuilder.create().isValuable("Null")).isFalse();
assertThat(PropertiesBuilder.create().isValuable("NULL")).isFalse();
}
@Test
public void emptyStringLiteralIsNotValuable() {
assertThat(PropertiesBuilder.create().isValuable(" "), is(false));
assertThat(PropertiesBuilder.create().isValuable(""), is(false));
assertThat(PropertiesBuilder.create().isValuable(" ")).isFalse();
assertThat(PropertiesBuilder.create().isValuable("")).isFalse();
}
}

45
spring-data-geode/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyConverterUnitTests.java
View File

@@ -13,34 +13,26 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.wan;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import org.junit.After;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.apache.geode.cache.wan.GatewaySender;
/**
* Unit tests for {@link OrderPolicyConverter}.
* Unit Tests for {@link OrderPolicyConverter}.
*
* @author John Blum
* @see org.junit.Test
* @see org.springframework.data.gemfire.wan.OrderPolicyConverter
* @see org.apache.geode.cache.util.Gateway.OrderPolicy
* @see org.springframework.data.gemfire.wan.OrderPolicyConverter
* @since 1.7.0
*/
public class OrderPolicyConverterUnitTests {
@Rule
public ExpectedException exception = ExpectedException.none();
private final OrderPolicyConverter converter = new OrderPolicyConverter();
@After
@@ -50,18 +42,25 @@ public class OrderPolicyConverterUnitTests {
@Test
public void convert() {
assertThat(converter.convert("key")).isEqualTo(GatewaySender.OrderPolicy.KEY);
assertThat(converter.convert("Partition")).isEqualTo(GatewaySender.OrderPolicy.PARTITION);
assertThat(converter.convert("THREAD")).isEqualTo(GatewaySender.OrderPolicy.THREAD);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void convertIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[process] is not a valid OrderPolicy");
converter.convert("process");
try {
converter.convert("process");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[process] is not a valid OrderPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
@Test
@@ -73,12 +72,18 @@ public class OrderPolicyConverterUnitTests {
assertThat(converter.getValue()).isEqualTo(GatewaySender.OrderPolicy.THREAD);
}
@Test
@Test(expected = IllegalArgumentException.class)
public void setAsTextWithIllegalValue() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("[value] is not a valid OrderPolicy");
converter.setAsText("value");
try {
converter.setAsText("value");
}
catch (IllegalArgumentException expected) {
assertThat(expected).hasMessage("[value] is not a valid OrderPolicy");
assertThat(expected).hasNoCause();
throw expected;
}
}
}