From 6714ed94219f9549b74de10f5b69bf02744b6e40 Mon Sep 17 00:00:00 2001 From: John Blum Date: Mon, 22 Oct 2018 19:05:04 -0700 Subject: [PATCH] Add Unit Tests for o.s.session.data.gemfire.expiration.SessionExpirationPolicy strategy interface and supporting classes. Resolves gh-5. --- .../SessionExpirationPolicyUnitTests.java | 68 +++++ ...nRepositoryBeanPostProcessorUnitTests.java | 97 +++++++ ...imeoutAwareBeanPostProcessorUnitTests.java | 116 +++++++++ ...nExpirationSessionRepositoryUnitTests.java | 210 +++++++++++++++ ...meoutSessionExpirationPolicyUnitTests.java | 114 ++++++++ ...meoutSessionExpirationPolicyUnitTests.java | 114 ++++++++ ...ionPolicyCustomExpiryAdapterUnitTests.java | 245 ++++++++++++++++++ 7 files changed, 964 insertions(+) create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/SessionExpirationPolicyUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/FixedDurationExpirationSessionRepositoryBeanPostProcessorUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/SessionExpirationTimeoutAwareBeanPostProcessorUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/repository/FixedDurationExpirationSessionRepositoryUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/FixedTimeoutSessionExpirationPolicyUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/IdleTimeoutSessionExpirationPolicyUnitTests.java create mode 100644 spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/SessionExpirationPolicyCustomExpiryAdapterUnitTests.java diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/SessionExpirationPolicyUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/SessionExpirationPolicyUnitTests.java new file mode 100644 index 0000000..6f2044f --- /dev/null +++ b/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); + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/FixedDurationExpirationSessionRepositoryBeanPostProcessorUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/FixedDurationExpirationSessionRepositoryBeanPostProcessorUnitTests.java new file mode 100644 index 0000000..e93a766 --- /dev/null +++ b/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 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.>invokeMethod(sessionRepository, "getDelegate")) + .isEqualTo(mockSessionRepository); + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/SessionExpirationTimeoutAwareBeanPostProcessorUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/config/SessionExpirationTimeoutAwareBeanPostProcessorUnitTests.java new file mode 100644 index 0000000..fdc4a02 --- /dev/null +++ b/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; + } + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/repository/FixedDurationExpirationSessionRepositoryUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/repository/FixedDurationExpirationSessionRepositoryUnitTests.java new file mode 100644 index 0000000..6711ced --- /dev/null +++ b/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 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 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 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 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 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 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()); + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/FixedTimeoutSessionExpirationPolicyUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/FixedTimeoutSessionExpirationPolicyUnitTests.java new file mode 100644 index 0000000..3ccad93 --- /dev/null +++ b/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(); + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/IdleTimeoutSessionExpirationPolicyUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/IdleTimeoutSessionExpirationPolicyUnitTests.java new file mode 100644 index 0000000..606c678 --- /dev/null +++ b/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(); + } +} diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/SessionExpirationPolicyCustomExpiryAdapterUnitTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/expiration/support/SessionExpirationPolicyCustomExpiryAdapterUnitTests.java new file mode 100644 index 0000000..c1d1e25 --- /dev/null +++ b/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 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 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 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 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 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 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)); + } +}