Add Unit Tests for o.s.session.data.gemfire.expiration.SessionExpirationPolicy strategy interface and supporting classes.

Resolves gh-5.

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/SessionExpirationPolicyUnitTests.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.springframework.session.data.gemfire.expiration.SessionExpirationPolicy.ExpirationAction;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+/**
+ * Unit tests for {@link SessionExpirationPolicy}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mock
+ * @see org.mockito.Mockito
+ * @see org.mockito.junit.MockitoJUnitRunner
+ * @see org.springframework.session.data.gemfire.expiration.SessionExpirationPolicy
+ * @see org.springframework.session.data.gemfire.expiration.SessionExpirationPolicy.ExpirationAction
+ * @since 2.1.0
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SessionExpirationPolicyUnitTests {
+
+	@Mock
+	private SessionExpirationPolicy mockSessionExpirationPolicy;
+
+	@Test
+	public void expirationActionDefaultsToInvalidate() {
+
+		when(this.mockSessionExpirationPolicy.getAction()).thenCallRealMethod();
+
+		assertThat(this.mockSessionExpirationPolicy.getAction())
+			.isEqualTo(SessionExpirationPolicy.ExpirationAction.INVALIDATE);
+
+		verify(this.mockSessionExpirationPolicy, times(1)).getAction();
+	}
+
+	@Test
+	public void expirationActionDefaultIfNullReturnsDefault() {
+		assertThat(ExpirationAction.defaultIfNull(null)).isEqualTo(ExpirationAction.INVALIDATE);
+	}
+
+	@Test
+	public void expirationActionDefaultIfNullReturnsExpirationAction() {
+		assertThat(ExpirationAction.defaultIfNull(ExpirationAction.DESTROY)).isEqualTo(ExpirationAction.DESTROY);
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/FixedDurationExpirationSessionRepositoryBeanPostProcessorUnitTests.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.config;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Method;
+import java.time.Duration;
+
+import org.junit.Test;
+
+import org.springframework.session.SessionRepository;
+import org.springframework.session.data.gemfire.expiration.repository.FixedDurationExpirationSessionRepository;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * Unit tests for {@link FixedDurationExpirationSessionRepositoryBeanPostProcessor}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mockito
+ * @see org.springframework.session.data.gemfire.expiration.config.FixedDurationExpirationSessionRepositoryBeanPostProcessor
+ * @since 2.1.0
+ */
+public class FixedDurationExpirationSessionRepositoryBeanPostProcessorUnitTests {
+
+	@SuppressWarnings("unchecked")
+	private <T> T invokeMethod(Object target, String methodName) throws NoSuchMethodException {
+
+		Method method = target.getClass().getDeclaredMethod(methodName);
+
+		ReflectionUtils.makeAccessible(method);
+
+		return (T) ReflectionUtils.invokeMethod(method, target);
+	}
+
+	@Test
+	public void constructsFixedDurationExpirationSessionRepositoryBeanPostProcessor() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30L);
+
+		FixedDurationExpirationSessionRepositoryBeanPostProcessor beanPostProcessor =
+			new FixedDurationExpirationSessionRepositoryBeanPostProcessor(expirationTimeout);
+
+		assertThat(beanPostProcessor).isNotNull();
+		assertThat(beanPostProcessor.getExpirationTimeout()).isEqualTo(expirationTimeout);
+	}
+
+	@Test
+	public void doesNotProcessNonSessionRepositoryBeans() {
+
+		FixedDurationExpirationSessionRepositoryBeanPostProcessor beanPostProcessor =
+			new FixedDurationExpirationSessionRepositoryBeanPostProcessor(null);
+
+		Object bean = beanPostProcessor.postProcessAfterInitialization("test", "testBean");
+
+		assertThat(bean).isNotInstanceOf(SessionRepository.class);
+		assertThat(bean).isEqualTo("test");
+	}
+
+	@Test
+	@SuppressWarnings("all")
+	public void processesSessionRepositoryBean() throws Exception {
+
+		Duration expirationTimeout = Duration.ofMinutes(30);
+
+		SessionRepository<?> mockSessionRepository = mock(SessionRepository.class);
+
+		FixedDurationExpirationSessionRepositoryBeanPostProcessor beanPostProcessor =
+			new FixedDurationExpirationSessionRepositoryBeanPostProcessor(expirationTimeout);
+
+		Object sessionRepository =
+			beanPostProcessor.postProcessAfterInitialization(mockSessionRepository, "sessionRepository");
+
+		assertThat(sessionRepository).isNotSameAs(mockSessionRepository);
+		assertThat(sessionRepository).isInstanceOf(FixedDurationExpirationSessionRepository.class);
+		assertThat(((FixedDurationExpirationSessionRepository<?>) sessionRepository).getExpirationTimeout()
+			.orElse(null)).isEqualTo(expirationTimeout);
+		assertThat(this.<SessionRepository<?>>invokeMethod(sessionRepository, "getDelegate"))
+			.isEqualTo(mockSessionRepository);
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/SessionExpirationTimeoutAwareBeanPostProcessorUnitTests.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.config;
+
+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;
+
+import java.time.Duration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+/**
+ * Unit tests for {@link SessionExpirationTimeoutAwareBeanPostProcessor}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mock
+ * @see org.mockito.Mockito
+ * @see org.mockito.junit.MockitoJUnitRunner
+ * @see org.springframework.session.data.gemfire.expiration.config.SessionExpirationTimeoutAware
+ * @see org.springframework.session.data.gemfire.expiration.config.SessionExpirationTimeoutAwareBeanPostProcessor
+ * @since 1.0.0
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SessionExpirationTimeoutAwareBeanPostProcessorUnitTests {
+
+	@Test
+	public void constructsSessionExpirationTimeoutAwareBeanPostProcessor() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30L);
+
+		SessionExpirationTimeoutAwareBeanPostProcessor beanPostProcessor =
+			new SessionExpirationTimeoutAwareBeanPostProcessor(expirationTimeout);
+
+		assertThat(beanPostProcessor).isNotNull();
+		assertThat(beanPostProcessor.getExpirationTimeout()).isEqualTo(expirationTimeout);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructsSessionExpirationTimeoutAwareBeanPostProcessorWithNullExpirationTimeout() {
+
+		try {
+			new SessionExpirationTimeoutAwareBeanPostProcessor(null);
+		}
+		catch (IllegalArgumentException expected) {
+
+			assertThat(expected).hasMessage("Expiration timeout is required");
+			assertThat(expected).hasNoCause();
+
+			throw expected;
+		}
+	}
+
+	@Test
+	public void configuresSessionExpirationTimeoutAwareBean() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30L);
+
+		SessionExpirationTimeoutAware bean = mock(SessionExpirationTimeoutAware.class);
+
+		SessionExpirationTimeoutAwareBeanPostProcessor beanPostProcessor =
+			new SessionExpirationTimeoutAwareBeanPostProcessor(expirationTimeout);
+
+		assertThat(beanPostProcessor.postProcessBeforeInitialization(bean, "testBean")).isSameAs(bean);
+
+		verify(bean, times(1)).setExpirationTimeout(eq(expirationTimeout));
+	}
+
+	@Test
+	public void doesNotConfigureNonSessionExpirationTimeoutAwareBean() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30L);
+
+		SessionExpirationTimeoutAwareBeanPostProcessor beanPostProcessor =
+			new SessionExpirationTimeoutAwareBeanPostProcessor(expirationTimeout);
+
+		TestBean bean = new TestBean();
+
+		assertThat(bean.getExpirationTimeout()).isNull();
+		assertThat(beanPostProcessor.postProcessBeforeInitialization(bean, "testBean")).isSameAs(bean);
+		assertThat(bean.getExpirationTimeout()).isNull();
+	}
+
+	@SuppressWarnings("unused")
+	class TestBean {
+
+		private Duration expirationTimeout;
+
+		Duration getExpirationTimeout() {
+			return this.expirationTimeout;
+		}
+
+		void setExpirationTimeout(Duration expirationTimeout) {
+			this.expirationTimeout = expirationTimeout;
+		}
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/repository/FixedDurationExpirationSessionRepositoryUnitTests.java

@@ -0,0 +1,210 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+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.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.time.Instant;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import org.springframework.session.Session;
+import org.springframework.session.SessionRepository;
+
+/**
+ * Unit tests {@link FixedDurationExpirationSessionRepository}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mock
+ * @see org.mockito.Mockito
+ * @see org.mockito.junit.MockitoJUnitRunner
+ * @see org.springframework.session.Session
+ * @see org.springframework.session.SessionRepository
+ * @see org.springframework.session.data.gemfire.expiration.repository.FixedDurationExpirationSessionRepository
+ * @since 2.1.0
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class FixedDurationExpirationSessionRepositoryUnitTests {
+
+	@Mock
+	private SessionRepository<Session> mockSessionRepository;
+
+	@Test
+	public void constructsFixedDurationExpirationSessionRepository() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30L);
+
+		FixedDurationExpirationSessionRepository<?> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, expirationTimeout);
+
+		assertThat(sessionRepository).isNotNull();
+		assertThat(sessionRepository.getDelegate()).isEqualTo(this.mockSessionRepository);
+		assertThat(sessionRepository.getExpirationTimeout().orElse(null)).isEqualTo(expirationTimeout);
+	}
+
+	@Test
+	public void constructsFixedDurationExpirationSessionRepositoryWithNullExpirationTimeout() {
+
+		FixedDurationExpirationSessionRepository<?> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, null);
+
+		assertThat(sessionRepository).isNotNull();
+		assertThat(sessionRepository.getDelegate()).isEqualTo(this.mockSessionRepository);
+		assertThat(sessionRepository.getExpirationTimeout().orElse(null)).isNull();
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructFixedDurationExpirationSessionRepositoryWithNullSessionRepository() {
+
+		try {
+			new FixedDurationExpirationSessionRepository<>(null, Duration.ofMinutes(30L));
+		}
+		catch (IllegalArgumentException expected) {
+
+			assertThat(expected).hasMessage("SessionRepository is required");
+			assertThat(expected).hasNoCause();
+
+			throw expected;
+		}
+	}
+
+	@Test
+	public void createSessionCallsDelegate() {
+
+		Session mockSession = mock(Session.class);
+
+		when(this.mockSessionRepository.createSession()).thenReturn(mockSession);
+
+		FixedDurationExpirationSessionRepository<?> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		assertThat(sessionRepository.createSession()).isEqualTo(mockSession);
+
+		verify(this.mockSessionRepository, times(1)).createSession();
+	}
+
+	@Test
+	public void deleteByIdCallsDelegate() {
+
+		FixedDurationExpirationSessionRepository<?> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		sessionRepository.deleteById("1");
+
+		verify(this.mockSessionRepository, times(1)).deleteById(eq("1"));
+	}
+
+	@Test
+	public void saveCallsDelegate() {
+
+		Session mockSession = mock(Session.class);
+
+		FixedDurationExpirationSessionRepository<Session> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		sessionRepository.save(mockSession);
+
+		verify(this.mockSessionRepository, times(1)).save(eq(mockSession));
+	}
+
+	@Test
+	public void findByIdHandlesNullSessionCorrectly() {
+
+		when(this.mockSessionRepository.findById(anyString())).thenReturn(null);
+
+		FixedDurationExpirationSessionRepository<Session> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		assertThat(sessionRepository.findById("1")).isNull();
+
+		verify(this.mockSessionRepository, times(1)).findById(eq("1"));
+		verifyNoMoreInteractions(this.mockSessionRepository);
+	}
+
+	@Test
+	public void findByIdHandlesNullExpirationTimeoutCorrectly() {
+
+		Session mockSession = mock(Session.class);
+
+		when(this.mockSessionRepository.findById(anyString())).thenReturn(mockSession);
+
+		FixedDurationExpirationSessionRepository<Session> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, null);
+
+		assertThat(sessionRepository.findById("1")).isEqualTo(mockSession);
+
+		verify(this.mockSessionRepository, times(1)).findById(eq("1"));
+		verifyNoMoreInteractions(this.mockSessionRepository);
+		verifyZeroInteractions(mockSession);
+	}
+
+	@Test
+	public void findByIdHandlesExpiredSessionCorrectly() {
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getCreationTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofMinutes(31L).toMillis()));
+
+		when(mockSession.getId()).thenReturn("1");
+
+		when(this.mockSessionRepository.findById(anyString())).thenReturn(mockSession);
+
+		FixedDurationExpirationSessionRepository<Session> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		assertThat(sessionRepository.findById("1")).isNull();
+
+		verify(mockSession, never()).getLastAccessedTime();
+		verify(this.mockSessionRepository, times(1)).findById(eq("1"));
+		verify(this.mockSessionRepository, times(1)).deleteById(eq("1"));
+	}
+
+	@Test
+	public void findByIdHandlesActiveSessionCorrectly() {
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getCreationTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofMinutes(15L).toMillis()));
+
+		when(this.mockSessionRepository.findById(anyString())).thenReturn(mockSession);
+
+		FixedDurationExpirationSessionRepository<Session> sessionRepository =
+			new FixedDurationExpirationSessionRepository<>(this.mockSessionRepository, Duration.ofMinutes(30L));
+
+		assertThat(sessionRepository.findById("1")).isEqualTo(mockSession);
+
+		verify(mockSession, never()).getLastAccessedTime();
+		verify(this.mockSessionRepository, times(1)).findById(eq("1"));
+		verify(this.mockSessionRepository, never()).deleteById(anyString());
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/FixedTimeoutSessionExpirationPolicyUnitTests.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.support;
+
+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.when;
+
+import java.time.Duration;
+import java.time.Instant;
+
+import org.junit.Test;
+
+import org.springframework.session.Session;
+
+/**
+ * Unit tests for {@link FixedTimeoutSessionExpirationPolicy}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mockito
+ * @see org.springframework.session.Session
+ * @see org.springframework.session.data.gemfire.expiration.support.FixedTimeoutSessionExpirationPolicy
+ * @since 2.1.0
+ */
+public class FixedTimeoutSessionExpirationPolicyUnitTests {
+
+	@Test
+	public void constructsFixedTimeoutSessionExpirationPolicy() {
+
+		Duration fixedExpirationTimeout = Duration.ofSeconds(60);
+
+		FixedTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new FixedTimeoutSessionExpirationPolicy(fixedExpirationTimeout);
+
+		assertThat(sessionExpirationPolicy).isNotNull();
+		assertThat(sessionExpirationPolicy.getFixedExpirationTimeout()).isEqualTo(fixedExpirationTimeout);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructsFixedTimeoutSessionExpirationPolicyWithNullDuration() {
+
+		try {
+			new FixedTimeoutSessionExpirationPolicy(null);
+		}
+		catch (IllegalArgumentException expected) {
+
+			assertThat(expected).hasMessage("Fixed expiration timeout is required");
+			assertThat(expected).hasNoCause();
+
+			throw expected;
+		}
+	}
+
+	@Test
+	public void expireAfterReturnsFutureDuration() {
+
+		Duration expirationTimeout = Duration.ofSeconds(30);
+
+		FixedTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new FixedTimeoutSessionExpirationPolicy(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getCreationTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofSeconds(15).toMillis()));
+
+		Duration expireAfter = sessionExpirationPolicy.expireAfter(mockSession);
+
+		assertThat(expireAfter).isNotNull();
+		assertThat(expireAfter.getSeconds()).isLessThanOrEqualTo(15);
+
+		verify(mockSession, times(1)).getCreationTime();
+		verify(mockSession, never()).getLastAccessedTime();
+	}
+
+	@Test
+	public void expireAfterReturnsZero() {
+
+		Duration expirationTimeout = Duration.ofSeconds(30);
+
+		FixedTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new FixedTimeoutSessionExpirationPolicy(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getCreationTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofSeconds(60).toMillis()));
+
+		Duration expireAfter = sessionExpirationPolicy.expireAfter(mockSession);
+
+		assertThat(expireAfter).isEqualTo(Duration.ZERO);
+
+		verify(mockSession, times(1)).getCreationTime();
+		verify(mockSession, never()).getLastAccessedTime();
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/IdleTimeoutSessionExpirationPolicyUnitTests.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.support;
+
+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.when;
+
+import java.time.Duration;
+import java.time.Instant;
+
+import org.junit.Test;
+
+import org.springframework.session.Session;
+
+/**
+ * Unit tests for {@link IdleTimeoutSessionExpirationPolicy}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mockito
+ * @see org.springframework.session.Session
+ * @see org.springframework.session.data.gemfire.expiration.support.IdleTimeoutSessionExpirationPolicy
+ * @since 2.1.0
+ */
+public class IdleTimeoutSessionExpirationPolicyUnitTests {
+
+	@Test
+	public void constructIdleTimeoutSessionExpirationPolicy() {
+
+		Duration idleExpirationTimeout = Duration.ofSeconds(60);
+
+		IdleTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new IdleTimeoutSessionExpirationPolicy(idleExpirationTimeout);
+
+		assertThat(sessionExpirationPolicy).isNotNull();
+		assertThat(sessionExpirationPolicy.getIdleExpirationTimeout()).isEqualTo(idleExpirationTimeout);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructIdleTimeoutSessionExpirationPolicyWithNullDuration() {
+
+		try {
+			new IdleTimeoutSessionExpirationPolicy(null);
+		}
+		catch (IllegalArgumentException expected) {
+
+			assertThat(expected).hasMessage("Idle expiration timeout is required");
+			assertThat(expected).hasNoCause();
+
+			throw expected;
+		}
+	}
+
+	@Test
+	public void expireAfterReturnsFutureDuration() {
+
+		Duration expirationTimeout = Duration.ofSeconds(30);
+
+		IdleTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new IdleTimeoutSessionExpirationPolicy(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getLastAccessedTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofSeconds(15).toMillis()));
+
+		Duration expireAfter = sessionExpirationPolicy.expireAfter(mockSession);
+
+		assertThat(expireAfter).isNotNull();
+		assertThat(expireAfter.getSeconds()).isLessThanOrEqualTo(15);
+
+		verify(mockSession, times(1)).getLastAccessedTime();
+		verify(mockSession, never()).getCreationTime();
+	}
+
+	@Test
+	public void expireAfterReturnsZero() {
+
+		Duration expirationTimeout = Duration.ofSeconds(30);
+
+		IdleTimeoutSessionExpirationPolicy sessionExpirationPolicy =
+			new IdleTimeoutSessionExpirationPolicy(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		when(mockSession.getLastAccessedTime())
+			.thenReturn(Instant.ofEpochMilli(System.currentTimeMillis() - Duration.ofSeconds(60).toMillis()));
+
+		Duration expireAfter = sessionExpirationPolicy.expireAfter(mockSession);
+
+		assertThat(expireAfter).isEqualTo(Duration.ZERO);
+
+		verify(mockSession, times(1)).getLastAccessedTime();
+		verify(mockSession, never()).getCreationTime();
+	}
+}

spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/SessionExpirationPolicyCustomExpiryAdapterUnitTests.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2017 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.session.data.gemfire.expiration.support;
+
+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.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import org.apache.geode.cache.ExpirationAction;
+import org.apache.geode.cache.ExpirationAttributes;
+import org.apache.geode.cache.Region;
+import org.apache.geode.pdx.PdxInstance;
+
+import org.springframework.session.Session;
+import org.springframework.session.data.gemfire.expiration.SessionExpirationPolicy;
+
+/**
+ * Unit tests for {@link SessionExpirationPolicyCustomExpiryAdapter}.
+ *
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.mockito.Mock
+ * @see org.mockito.Mockito
+ * @see org.mockito.junit.MockitoJUnitRunner
+ * @see org.springframework.session.data.gemfire.expiration.support.SessionExpirationPolicyCustomExpiryAdapter
+ * @since 2.1.0
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SessionExpirationPolicyCustomExpiryAdapterUnitTests {
+
+	@Mock
+	private SessionExpirationPolicy mockSessionExpirationPolicy;
+
+	@Test
+	public void constructsNewSessionExpirationPolicyCustomExpiryAdapter() {
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		assertThat(adapter).isNotNull();
+		assertThat(adapter.getSessionExpirationPolicy()).isEqualTo(this.mockSessionExpirationPolicy);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructNewSessionExpirationPolicyCustomExpiryAdapterWithNullSessionExpirationPolicy() {
+
+		try {
+			new SessionExpirationPolicyCustomExpiryAdapter(null);
+		}
+		catch (IllegalArgumentException expected) {
+
+			assertThat(expected).hasMessage("SessionExpirationPolicy is required");
+			assertThat(expected).hasNoCause();
+
+			throw expected;
+		}
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryHandlesInvalidRegionEntryValueType() {
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		when(mockRegionEntry.getValue()).thenReturn("MockSession");
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		assertThat(adapter.getExpiry(mockRegionEntry)).isNull();
+
+		verify(mockRegionEntry, times(1)).getValue();
+		verifyZeroInteractions(this.mockSessionExpirationPolicy);
+	}
+
+	@Test
+	public void getExpiryHandlesNullRegionEntry() {
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		assertThat(adapter.getExpiry(null)).isNull();
+
+		verifyZeroInteractions(this.mockSessionExpirationPolicy);
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryHandlesNullRegionEntryPdxInstanceObject() {
+
+		PdxInstance mockPdxInstance = mock(PdxInstance.class);
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		when(mockPdxInstance.getObject()).thenReturn(null);
+		when(mockRegionEntry.getValue()).thenReturn(mockPdxInstance);
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		assertThat(adapter.getExpiry(mockRegionEntry)).isNull();
+
+		verify(mockPdxInstance, times(1)).getObject();
+		verify(mockRegionEntry, times(1)).getValue();
+		verifyZeroInteractions(this.mockSessionExpirationPolicy);
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryHandlesNullRegionEntryValue() {
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		when(mockRegionEntry.getValue()).thenReturn(null);
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		assertThat(adapter.getExpiry(mockRegionEntry)).isNull();
+
+		verify(mockRegionEntry, times(1)).getValue();
+		verifyZeroInteractions(this.mockSessionExpirationPolicy);
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryReturnsExpirationAttributes() {
+
+		Duration expirationTimeout = Duration.ofMinutes(30);
+
+		SessionExpirationPolicy.ExpirationAction expirationAction = SessionExpirationPolicy.ExpirationAction.DESTROY;
+
+		when(this.mockSessionExpirationPolicy.getAction()).thenReturn(expirationAction);
+		when(this.mockSessionExpirationPolicy.expireAfter(any(Session.class))).thenReturn(expirationTimeout);
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		Session mockSession = mock(Session.class);
+
+		when(mockRegionEntry.getValue()).thenReturn(mockSession);
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		ExpirationAttributes expirationAttributes = adapter.getExpiry(mockRegionEntry);
+
+		assertThat(expirationAttributes).isNotNull();
+		assertThat(expirationAttributes.getAction()).isEqualTo(ExpirationAction.DESTROY);
+		assertThat(expirationAttributes.getTimeout()).isEqualTo(expirationTimeout.getSeconds());
+
+		verify(mockRegionEntry, times(1)).getValue();
+		verify(this.mockSessionExpirationPolicy, times(1)).getAction();
+		verify(this.mockSessionExpirationPolicy, times(1)).expireAfter(eq(mockSession));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryWithPdxInstanceAndOverflowedExpirationTimeoutAndNullExpirationAction() {
+
+		Duration expirationTimeout = Duration.ofSeconds(987654321369L);
+
+		when(this.mockSessionExpirationPolicy.getAction()).thenReturn(null);
+		when(this.mockSessionExpirationPolicy.expireAfter(any(Session.class))).thenReturn(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		PdxInstance mockPdxInstance = mock(PdxInstance.class);
+
+		when(mockPdxInstance.getObject()).thenReturn(mockSession);
+		when(mockRegionEntry.getValue()).thenReturn(mockPdxInstance);
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		ExpirationAttributes expirationAttributes = adapter.getExpiry(mockRegionEntry);
+
+		assertThat(expirationAttributes).isNotNull();
+		assertThat(expirationAttributes.getAction()).isEqualTo(ExpirationAction.INVALIDATE);
+		assertThat(expirationAttributes.getTimeout()).isEqualTo(Integer.MAX_VALUE);
+
+		verify(mockPdxInstance, times(1)).getObject();
+		verify(mockRegionEntry, times(1)).getValue();
+		verify(this.mockSessionExpirationPolicy, times(1)).getAction();
+		verify(this.mockSessionExpirationPolicy, times(1)).expireAfter(eq(mockSession));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void getExpiryWithUnderflowExpirationTimeout() {
+
+		Duration expirationTimeout = Duration.ofSeconds(-120);
+
+		SessionExpirationPolicy.ExpirationAction expirationAction = SessionExpirationPolicy.ExpirationAction.DESTROY;
+
+		when(this.mockSessionExpirationPolicy.getAction()).thenReturn(expirationAction);
+		when(this.mockSessionExpirationPolicy.expireAfter(any(Session.class))).thenReturn(expirationTimeout);
+
+		Session mockSession = mock(Session.class);
+
+		Region.Entry<String, Object> mockRegionEntry = mock(Region.Entry.class);
+
+		when(mockRegionEntry.getValue()).thenReturn(mockSession);
+
+		SessionExpirationPolicyCustomExpiryAdapter adapter =
+			new SessionExpirationPolicyCustomExpiryAdapter(this.mockSessionExpirationPolicy);
+
+		ExpirationAttributes expirationAttributes = adapter.getExpiry(mockRegionEntry);
+
+		assertThat(expirationAttributes).isNotNull();
+		assertThat(expirationAttributes.getAction()).isEqualTo(ExpirationAction.DESTROY);
+		assertThat(expirationAttributes.getTimeout()).isEqualTo(1);
+
+		verify(mockRegionEntry, times(1)).getValue();
+		verify(this.mockSessionExpirationPolicy, times(1)).getAction();
+		verify(this.mockSessionExpirationPolicy, times(1)).expireAfter(eq(mockSession));
+	}
+}