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

SGF-404 - Enable Expiration settings and policies to be specified per application domain object using an @Expiration annotation and a custom, SDG-provided CustomExpiry instance.

Browse Source 
(cherry picked from commit a9b7f9d8e8deca6aa198e24d441d8e77bf3247cc)

Signed-off-by: John Blum <jblum@pivotal.io>
This commit is contained in:
John Blum
2015-07-23 17:05:14 -07:00
parent 75598064d3
commit 16ebd5a0f6
7 changed files with 1067 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
src/test/java/org/springframework/data/gemfire/support/AnnotationBasedExpirationConfigurationIntegrationTest.java Normal file
View File

@@ -0,0 +1,160 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.annotation.Resource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.gemfire.ExpirationActionType;
import org.springframework.data.gemfire.test.GemfireTestApplicationContextInitializer;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.gemstone.gemfire.cache.CustomExpiry;
import com.gemstone.gemfire.cache.ExpirationAction;
import com.gemstone.gemfire.cache.ExpirationAttributes;
import com.gemstone.gemfire.cache.Region;
/**
* The AnnotationBasedExpirationConfigurationIntegrationTest class is a test suite of test cases testing
* the configuration of Annotation-defined expiration policies on Region Entry TTL and TTI
* custom expiration settings.
*
* @author John Blum
* @see org.junit.Test
* @see org.junit.runner.RunWith
* @see org.mockito.Mockito
* @see org.springframework.data.gemfire.support.AnnotationBasedExpiration
* @see org.springframework.data.gemfire.test.GemfireTestApplicationContextInitializer
* @see org.springframework.test.context.ContextConfiguration
* @see org.springframework.test.context.junit4.SpringJUnit4ClassRunner
* @since 1.7.0
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(initializers = GemfireTestApplicationContextInitializer.class)
@SuppressWarnings("unused")
public class AnnotationBasedExpirationConfigurationIntegrationTest {
@Autowired
@Qualifier("ttiExpiration")
private AnnotationBasedExpiration<Object, Object> idleTimeoutExpiration;
@Autowired
@Qualifier("ttlExpiration")
private AnnotationBasedExpiration<Object, Object> timeToLiveExpiration;
@Autowired
private ExpirationAttributes defaultExpirationAttributes;
@Resource(name = "Example")
private Region<Object, Object> example;
@Before
public void setup() {
assertThat(example, is(not(nullValue())));
assertThat(example.getName(), is(equalTo("Example")));
assertThat(example.getFullPath(), is(equalTo(String.format("%1$s%2$s", Region.SEPARATOR, "Example"))));
assertThat(example.getAttributes(), is(not(nullValue())));
assertThat(defaultExpirationAttributes, is(not(nullValue())));
assertThat(defaultExpirationAttributes.getTimeout(), is(equalTo(600)));
assertThat(defaultExpirationAttributes.getAction(), is(equalTo(ExpirationAction.DESTROY)));
assertThat(idleTimeoutExpiration, is(instanceOf(CustomExpiry.class)));
assertThat(idleTimeoutExpiration.getDefaultExpirationAttributes(), is(nullValue()));
assertThat(timeToLiveExpiration, is(instanceOf(CustomExpiry.class)));
assertThat(timeToLiveExpiration.getDefaultExpirationAttributes(), is(sameInstance(defaultExpirationAttributes)));
}
protected void assertExpiration(ExpirationAttributes expected, ExpirationAttributes actual) {
assertExpiration(actual, expected.getTimeout(), expected.getAction());
}
protected void assertExpiration(ExpirationAttributes expirationAttributes, int expectedTimeout,
ExpirationAction expectedAction) {
assertThat(expirationAttributes, is(not(nullValue())));
assertThat(expirationAttributes.getTimeout(), is(equalTo(expectedTimeout)));
assertThat(expirationAttributes.getAction(), is(equalTo(expectedAction)));
}
@SuppressWarnings("unchecked")
protected Region.Entry<Object, Object> mockRegionEntry(Object value) {
Region.Entry<Object, Object> mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(value);
return mockRegionEntry;
}
@Test
public void exampleRegionIdleTimeoutExpirationPolicy() {
CustomExpiry<Object, Object> expiration = example.getAttributes().getCustomEntryIdleTimeout();
assertExpiration(expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithIdleTimeoutExpirationPolicy())), 120, ExpirationAction.INVALIDATE);
assertExpiration(expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithTimeToLiveGenericExpirationPolicies())), 60, ExpirationAction.INVALIDATE);
assertExpiration(expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithGenericExpirationPolicy())), 60, ExpirationAction.DESTROY);
assertThat(expiration.getExpiry(mockRegionEntry(new ApplicationDomainObjectWithNoExpirationPolicy())),
is(nullValue()));
}
@Test
public void exampleRegionTimeToLiveExpirationPolicy() {
CustomExpiry<Object, Object> expiration = example.getAttributes().getCustomEntryTimeToLive();
assertExpiration(expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithTimeToLiveGenericExpirationPolicies())), 300, ExpirationAction.DESTROY);
assertExpiration(defaultExpirationAttributes, expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithIdleTimeoutExpirationPolicy())));
assertExpiration(expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithGenericExpirationPolicy())), 60, ExpirationAction.DESTROY);
assertExpiration(defaultExpirationAttributes, expiration.getExpiry(mockRegionEntry(
new ApplicationDomainObjectWithNoExpirationPolicy())));
}
@Expiration(timeout = 60, action = ExpirationActionType.INVALIDATE)
@TimeToLiveExpiration(timeout = 300, action = ExpirationActionType.DESTROY)
protected static class ApplicationDomainObjectWithTimeToLiveGenericExpirationPolicies {
}
@IdleTimeoutExpiration(timeout = 120, action = ExpirationActionType.INVALIDATE)
protected static class ApplicationDomainObjectWithIdleTimeoutExpirationPolicy {
}
@Expiration(timeout = 60, action = ExpirationActionType.DESTROY)
protected static class ApplicationDomainObjectWithGenericExpirationPolicy {
}
protected static class ApplicationDomainObjectWithNoExpirationPolicy {
}
}

389
src/test/java/org/springframework/data/gemfire/support/AnnotationBasedExpirationTest.java Normal file
View File

@@ -0,0 +1,389 @@
/*
* Copyright 2010-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.gemfire.support;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.atLeast;
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.support.AnnotationBasedExpiration.ExpirationMetaData;
import org.junit.Test;
import org.springframework.data.gemfire.ExpirationActionType;
import com.gemstone.gemfire.cache.ExpirationAction;
import com.gemstone.gemfire.cache.ExpirationAttributes;
import com.gemstone.gemfire.cache.Region;
/**
* The AnnotationBasedExpirationTest class is a test suite of test cases testing the contract and functionality
* of the AnnotationBasedExpirationTest.
*
* @author John Blum
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.data.gemfire.support.AnnotationBasedExpiration
* @since 1.7.0
*/
@SuppressWarnings({ "rawtypes", "unchecked", "unused" })
public class AnnotationBasedExpirationTest {
private AnnotationBasedExpiration noDefaultExpiration = new AnnotationBasedExpiration();
protected void assertExpiration(ExpirationAttributes expirationAttributes, int expectedTimeout,
ExpirationAction expectedAction) {
assertThat(expirationAttributes, is(not(nullValue())));
assertThat(expirationAttributes.getTimeout(), is(equalTo(expectedTimeout)));
assertThat(expirationAttributes.getAction(), is(equalTo(expectedAction)));
}
protected void assertExpiration(ExpirationMetaData expirationMetaData, int expectedTimeout,
ExpirationActionType expectedExpirationAction) {
assertThat(expirationMetaData, is(not(nullValue())));
assertThat(expirationMetaData.timeout(), is(equalTo(expectedTimeout)));
assertThat(expirationMetaData.action(), is(equalTo(expectedExpirationAction)));
}
@Test
public void constructUninitializedAnnotationBasedExpirationInstance() {
AnnotationBasedExpiration expiration = new AnnotationBasedExpiration();
assertThat(expiration.getDefaultExpirationAttributes(), is(nullValue()));
}
@Test
public void constructInitializedAnnotationBasedExpirationInstance() {
AnnotationBasedExpiration expiration = new AnnotationBasedExpiration(ExpirationAttributes.DEFAULT);
assertThat(expiration.getDefaultExpirationAttributes(), is(equalTo(ExpirationAttributes.DEFAULT)));
}
@Test
public void forIdleTimeoutNoDefaultExpiration() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
AnnotationBasedExpiration expiration = AnnotationBasedExpiration.forIdleTimeout();
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 120, ExpirationAction.LOCAL_INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 60, ExpirationAction.INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(expiration.getExpiry(mockRegionEntry), is(nullValue()));
verify(mockRegionEntry, atLeast(3)).getValue();
}
@Test
public void forIdleTimeoutWithDefaultExpiration() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
ExpirationAttributes defaultExpiration = new ExpirationAttributes(300, ExpirationAction.DESTROY);
AnnotationBasedExpiration expiration = AnnotationBasedExpiration.forIdleTimeout(defaultExpiration);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 120, ExpirationAction.LOCAL_INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 60, ExpirationAction.INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(expiration.getExpiry(mockRegionEntry), is(equalTo(defaultExpiration)));
verify(mockRegionEntry, atLeast(3)).getValue();
}
@Test
public void forTimeToLiveNoDefaultExpiration() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
AnnotationBasedExpiration expiration = AnnotationBasedExpiration.forTimeToLive();
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 300, ExpirationAction.LOCAL_DESTROY);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutGenericExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 60, ExpirationAction.INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(expiration.getExpiry(mockRegionEntry), is(nullValue()));
verify(mockRegionEntry, atLeast(3)).getValue();
}
@Test
public void forTimeToLiveWithDefaultExpiration() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
ExpirationAttributes defaultExpiration = new ExpirationAttributes(300, ExpirationAction.DESTROY);
AnnotationBasedExpiration expiration = AnnotationBasedExpiration.forTimeToLive(defaultExpiration);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 300, ExpirationAction.LOCAL_DESTROY);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutGenericExpiration());
assertExpiration(expiration.getExpiry(mockRegionEntry), 60, ExpirationAction.INVALIDATE);
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(expiration.getExpiry(mockRegionEntry), is(equalTo(defaultExpiration)));
verify(mockRegionEntry, atLeast(3)).getValue();
}
@Test
public void setAndGetDefaultExpirationAttributes() {
ExpirationAttributes expectedExpirationAttributes = new ExpirationAttributes(120, ExpirationAction.INVALIDATE);
AnnotationBasedExpiration expiration = new AnnotationBasedExpiration();
expiration.setDefaultExpirationAttributes(expectedExpirationAttributes);
assertThat(expiration.getDefaultExpirationAttributes(), is(equalTo(expectedExpirationAttributes)));
expiration.setDefaultExpirationAttributes(null);
assertThat(expiration.getDefaultExpirationAttributes(), is(nullValue()));
expiration.setDefaultExpirationAttributes(ExpirationAttributes.DEFAULT);
assertThat(expiration.getDefaultExpirationAttributes(), is(equalTo(ExpirationAttributes.DEFAULT)));
}
@Test
public void getExpiryCallsGetExpirationMetaDataOnRegionEntryFollowedByNewExpirationAttributes() {
final ExpirationAttributes expectedExpirationAttributes = new ExpirationAttributes(60,
ExpirationAction.LOCAL_DESTROY);
final Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
AnnotationBasedExpiration expiration = new AnnotationBasedExpiration() {
@Override protected ExpirationMetaData getExpirationMetaData(Region.Entry entry) {
assertThat(entry, is(sameInstance(mockRegionEntry)));
return ExpirationMetaData.from(expectedExpirationAttributes);
}
@Override protected ExpirationAttributes newExpirationAttributes(ExpirationMetaData expirationMetaData) {
assertThat(expirationMetaData.timeout(), is(equalTo(expectedExpirationAttributes.getTimeout())));
assertThat(expirationMetaData.expirationAction(), is(equalTo(expectedExpirationAttributes.getAction())));
return expectedExpirationAttributes;
}
};
assertThat(expiration.getExpiry(mockRegionEntry), is(equalTo(expectedExpirationAttributes)));
}
@Test
public void isExpirationConfiguredWithGenericExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithGenericExpiration());
assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void isExpirationConfiguredWithNoGenericExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void isIdleTimeoutConfiguredWithIdleTimeoutExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutExpiration());
assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void isIdleTimeoutConfiguredWithNoIdleTimeoutExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration());
assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void isTimeToLiveConfiguredWithTimeToLiveExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveExpiration());
assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true));
verify(mockRegionEntry, times(2)).getValue();
}
public void isTimeToLiveConfiguredWithNoTimeToLiveExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(false));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(false));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getExpirationWithGenericExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithGenericExpiration());
assertThat(noDefaultExpiration.getExpiration(mockRegionEntry), isA(Expiration.class));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.getExpiration(mockRegionEntry), isA(Expiration.class));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getExpirationWithNoGenericExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration());
assertThat(noDefaultExpiration.getExpiration(mockRegionEntry), is(nullValue()));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.getExpiration(mockRegionEntry), is(nullValue()));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getIdleTimeoutWithIdleTimeoutExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutExpiration());
assertThat(noDefaultExpiration.getIdleTimeout(mockRegionEntry), isA(IdleTimeoutExpiration.class));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.getIdleTimeout(mockRegionEntry), isA(IdleTimeoutExpiration.class));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getIdleTimeoutWithNoIdleTimeoutExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration());
assertThat(noDefaultExpiration.getIdleTimeout(mockRegionEntry), is(nullValue()));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.getIdleTimeout(mockRegionEntry), is(nullValue()));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getTimeToLiveWithTimeToLiveExpirationBasedRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveExpiration());
assertThat(noDefaultExpiration.getTimeToLive(mockRegionEntry), isA(TimeToLiveExpiration.class));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.getTimeToLive(mockRegionEntry), isA(TimeToLiveExpiration.class));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void getTimeToLiveWithNoTimeToLiveExpirationRegionEntry() {
Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry");
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutGenericExpiration());
assertThat(noDefaultExpiration.getTimeToLive(mockRegionEntry), is(nullValue()));
when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration());
assertThat(noDefaultExpiration.getTimeToLive(mockRegionEntry), is(nullValue()));
verify(mockRegionEntry, times(2)).getValue();
}
@Test
public void fromExpiration() {
ExpirationMetaData expirationMetaData = ExpirationMetaData.from(
RegionEntryValueWithGenericExpiration.class.getAnnotation(Expiration.class));
assertExpiration(expirationMetaData, 60, ExpirationActionType.INVALIDATE);
}
@Test
public void fromExpirationIdleTimeout() {
ExpirationMetaData expirationMetaData = ExpirationMetaData.from(
RegionEntryValueWithIdleTimeoutExpiration.class.getAnnotation(IdleTimeoutExpiration.class));
assertExpiration(expirationMetaData, 120, ExpirationActionType.LOCAL_INVALIDATE);
}
@Test
public void fromExpirationTimeToLive() {
ExpirationMetaData expirationMetaData = ExpirationMetaData.from(
RegionEntryValueWithTimeToLiveExpiration.class.getAnnotation(TimeToLiveExpiration.class));
assertExpiration(expirationMetaData, 300, ExpirationActionType.LOCAL_DESTROY);
}
@Test
public void toExpirationAttributes() {
ExpirationMetaData expirationMetaData = new ExpirationMetaData(90, ExpirationActionType.DESTROY);
assertExpiration(expirationMetaData.toExpirationAttributes(), expirationMetaData.timeout(),
expirationMetaData.expirationAction());
}
@Expiration(timeout = 60, action = ExpirationActionType.INVALIDATE)
@IdleTimeoutExpiration(timeout = 120, action = ExpirationActionType.LOCAL_INVALIDATE)
@TimeToLiveExpiration(timeout = 300, action = ExpirationActionType.LOCAL_DESTROY)
public static class RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration {
}
@IdleTimeoutExpiration(timeout = 120, action = ExpirationActionType.LOCAL_INVALIDATE)
@TimeToLiveExpiration(timeout = 300, action = ExpirationActionType.LOCAL_DESTROY)
public static class RegionEntryValueWithTimeToLiveIdleTimeoutExpiration {
}
@Expiration(timeout = 60, action = ExpirationActionType.INVALIDATE)
@TimeToLiveExpiration(timeout = 300, action = ExpirationActionType.LOCAL_DESTROY)
public static class RegionEntryValueWithTimeToLiveGenericExpiration {
}
@TimeToLiveExpiration(timeout = 300, action = ExpirationActionType.LOCAL_DESTROY)
public static class RegionEntryValueWithTimeToLiveExpiration {
}
@Expiration(timeout = 60, action = ExpirationActionType.INVALIDATE)
@IdleTimeoutExpiration(timeout = 120, action = ExpirationActionType.LOCAL_INVALIDATE)
public static class RegionEntryValueWithIdleTimeoutGenericExpiration {
}
@IdleTimeoutExpiration(timeout = 120, action = ExpirationActionType.LOCAL_INVALIDATE)
public static class RegionEntryValueWithIdleTimeoutExpiration {
}
@Expiration(timeout = 60, action = ExpirationActionType.INVALIDATE)
public static class RegionEntryValueWithGenericExpiration {
}
public static class RegionEntryValueWithNoExpiration {
}
}