Refactoring: Split up JUnit extensions and implement RedisParameterResolver & RedisValidationExtension

Author: tobi-laa

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/cluster/EmbeddedRedisCluster.kt

@@ -0,0 +1,16 @@
+package io.github.tobi.laa.spring.boot.embedded.redis.cluster
+
+import io.github.tobi.laa.spring.boot.embedded.redis.junit.extension.RedisFlushAllExtension
+import io.github.tobi.laa.spring.boot.embedded.redis.server.RedisServerContextCustomizerFactory
+import org.junit.jupiter.api.extension.ExtendWith
+import org.springframework.test.context.ContextCustomizerFactories
+
+/**
+ * Annotation to enable an [embedded Redis cluster][redis.embedded.RedisCluster] for tests.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+@ExtendWith(RedisFlushAllExtension::class)
+@ContextCustomizerFactories(RedisServerContextCustomizerFactory::class)
+annotation class EmbeddedRedisCluster

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/junit/extension/EmbeddedRedisTest.kt

@@ -0,0 +1,13 @@
+package io.github.tobi.laa.spring.boot.embedded.redis.junit.extension
+
+import org.junit.jupiter.api.extension.ExtendWith
+
+/**
+ * Compound annotation to enable all JUnit 5 extensions for embedded Redis tests.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@ExtendWith(RedisValidationExtension::class)
+@ExtendWith(RedisParameterResolver::class)
+@ExtendWith(RedisFlushAllExtension::class)
+internal annotation class EmbeddedRedisTest

…ed/redis/EmbeddedRedisSpringExtension.kt …unit/extension/RedisFlushAllExtension.ktsrc/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/EmbeddedRedisSpringExtension.kt renamed to src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/junit/extension/RedisFlushAllExtension.kt src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/EmbeddedRedisSpringExtension.kt renamed to src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/junit/extension/RedisFlushAllExtension.kt

@@ -1,26 +1,18 @@
-package io.github.tobi.laa.spring.boot.embedded.redis
+package io.github.tobi.laa.spring.boot.embedded.redis.junit.extension
 
+import io.github.tobi.laa.spring.boot.embedded.redis.RedisFlushAll
 import io.github.tobi.laa.spring.boot.embedded.redis.RedisFlushAll.Mode.AFTER_CLASS
 import io.github.tobi.laa.spring.boot.embedded.redis.RedisFlushAll.Mode.AFTER_METHOD
-import org.junit.jupiter.api.extension.*
-import org.springframework.test.context.junit.jupiter.SpringExtension
+import io.github.tobi.laa.spring.boot.embedded.redis.RedisStore
+import org.junit.jupiter.api.extension.AfterAllCallback
+import org.junit.jupiter.api.extension.AfterEachCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.springframework.test.context.junit.jupiter.SpringExtension.getApplicationContext
 
-internal class EmbeddedRedisSpringExtension : BeforeAllCallback, AfterEachCallback, AfterAllCallback,
-    ParameterResolver {
-
-    override fun beforeAll(context: ExtensionContext?) {
-        // TODO("Not yet implemented")
-    }
-
-    override fun supportsParameter(parameterContext: ParameterContext?, extensionContext: ExtensionContext?): Boolean {
-        // TODO("Not yet implemented")
-        return false
-    }
-
-    override fun resolveParameter(parameterContext: ParameterContext?, extensionContext: ExtensionContext?): Any {
-        // TODO("Not yet implemented")
-        return Any()
-    }
+/**
+ * JUnit 5 extension to flush all Redis data after each test method or after all test methods of a test class.
+ */
+internal class RedisFlushAllExtension : AfterEachCallback, AfterAllCallback {
 
     override fun afterEach(extensionContext: ExtensionContext?) {
         if (flushAllMode(extensionContext) == AFTER_METHOD) {
@@ -39,7 +31,7 @@ internal class EmbeddedRedisSpringExtension : BeforeAllCallback, AfterEachCallba
     }
 
     private fun flushAll(extensionContext: ExtensionContext?) {
-        val applicationContext = SpringExtension.getApplicationContext(extensionContext!!)
+        val applicationContext = getApplicationContext(extensionContext!!)
         RedisStore.client(applicationContext)!!.flushAll()
     }
 }

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/junit/extension/RedisParameterResolver.kt

@@ -0,0 +1,60 @@
+package io.github.tobi.laa.spring.boot.embedded.redis.junit.extension
+
+import io.github.tobi.laa.spring.boot.embedded.redis.RedisStore
+import io.github.tobi.laa.spring.boot.embedded.redis.cluster.EmbeddedRedisCluster
+import io.github.tobi.laa.spring.boot.embedded.redis.server.EmbeddedRedisServer
+import io.github.tobi.laa.spring.boot.embedded.redis.shardedcluster.EmbeddedRedisShardedCluster
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.ParameterContext
+import org.junit.jupiter.api.extension.ParameterResolver
+import org.springframework.test.context.junit.jupiter.SpringExtension.getApplicationContext
+import redis.embedded.Redis
+import redis.embedded.RedisCluster
+import redis.embedded.RedisServer
+import redis.embedded.RedisShardedCluster
+
+/**
+ * JUnit 5 extension to resolve [Redis] parameters.
+ */
+internal class RedisParameterResolver : ParameterResolver {
+
+    override fun supportsParameter(parameterContext: ParameterContext?, extensionContext: ExtensionContext?): Boolean {
+        val type = parameterType(parameterContext)
+        return redisResolvable(type)
+                || redisServerResolvable(type, extensionContext)
+                || clusterResolvable(type, extensionContext)
+                || shardedClusterResolvable(type, extensionContext)
+    }
+
+    private fun parameterType(parameterContext: ParameterContext?): Class<*> {
+        return parameterContext!!.parameter.type
+    }
+
+    private fun redisResolvable(type: Class<*>): Boolean {
+        return type == Redis::class.java
+    }
+
+    private fun redisServerResolvable(type: Class<*>, extensionContext: ExtensionContext?): Boolean {
+        return type.isAssignableFrom(RedisServer::class.java)
+                && annotatedWith(extensionContext, EmbeddedRedisServer::class.java)
+    }
+
+    private fun clusterResolvable(type: Class<*>, extensionContext: ExtensionContext?): Boolean {
+        return type.isAssignableFrom(RedisCluster::class.java)
+                && annotatedWith(extensionContext, EmbeddedRedisCluster::class.java)
+    }
+
+    private fun shardedClusterResolvable(type: Class<*>, extensionContext: ExtensionContext?): Boolean {
+        return type.isAssignableFrom(RedisShardedCluster::class.java)
+                && annotatedWith(extensionContext, EmbeddedRedisShardedCluster::class.java)
+    }
+
+    private fun annotatedWith(extensionContext: ExtensionContext?, annotationType: Class<out Annotation>): Boolean {
+        return extensionContext!!.requiredTestClass.isAnnotationPresent(annotationType)
+    }
+
+    override fun resolveParameter(parameterContext: ParameterContext?, extensionContext: ExtensionContext?): Any {
+        val applicationContext = getApplicationContext(extensionContext!!)
+        return RedisStore.server(applicationContext)!!
+    }
+}

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/junit/extension/RedisValidationExtension.kt

@@ -0,0 +1,54 @@
+package io.github.tobi.laa.spring.boot.embedded.redis.junit.extension
+
+import io.github.tobi.laa.spring.boot.embedded.redis.cluster.EmbeddedRedisCluster
+import io.github.tobi.laa.spring.boot.embedded.redis.server.EmbeddedRedisServer
+import io.github.tobi.laa.spring.boot.embedded.redis.shardedcluster.EmbeddedRedisShardedCluster
+import org.junit.jupiter.api.extension.BeforeAllCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+
+/**
+ * JUnit 5 extension to validate that the API is used correctly.
+ */
+internal class RedisValidationExtension : BeforeAllCallback {
+
+    override fun beforeAll(context: ExtensionContext?) {
+        val embeddedRedisServer = annotation(context, EmbeddedRedisServer::class.java)
+        val embeddedRedisCluster = annotation(context, EmbeddedRedisCluster::class.java)
+        val embeddedRedisShardedCluster = annotation(context, EmbeddedRedisShardedCluster::class.java)
+        validateMutuallyExclusive(embeddedRedisServer, embeddedRedisCluster, embeddedRedisShardedCluster)
+        embeddedRedisServer?.let { validateServer(it) }
+        embeddedRedisCluster?.let { validateCluster(it) }
+        embeddedRedisShardedCluster?.let { validateShardedCluster(it) }
+    }
+
+    private fun validateMutuallyExclusive(
+        embeddedRedisServer: EmbeddedRedisServer?,
+        embeddedRedisCluster: EmbeddedRedisCluster?,
+        embeddedRedisShardedCluster: EmbeddedRedisShardedCluster?
+    ) {
+        val count = listOfNotNull(embeddedRedisServer, embeddedRedisCluster, embeddedRedisShardedCluster).count()
+        require(count <= 1) { "Only one of @EmbeddedRedisServer, @EmbeddedRedisCluster, @EmbeddedRedisShardedCluster is allowed" }
+    }
+
+    private fun validateServer(config: EmbeddedRedisServer) {
+        validatePort(config.port)
+        require(config.configFile.isEmpty() || config.settings.isEmpty()) { "Either 'configFile' or 'settings' can be set, but not both" }
+        require(config.customizer.all { it.constructors.any { it.parameters.isEmpty() } }) { "Customizers must have a no-arg constructor" }
+    }
+
+    private fun validateCluster(config: EmbeddedRedisCluster) {
+        TODO()
+    }
+
+    private fun validateShardedCluster(config: EmbeddedRedisShardedCluster) {
+        TODO()
+    }
+
+    private fun validatePort(port: Int) {
+        require(port in 0..65535) { "Port must be in range 0..65535" }
+    }
+
+    private fun <A : Annotation> annotation(extensionContext: ExtensionContext?, type: Class<A>): A? {
+        return extensionContext!!.requiredTestClass.getAnnotation(type)
+    }
+}

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/server/EmbeddedRedisServer.kt

@@ -1,7 +1,6 @@
 package io.github.tobi.laa.spring.boot.embedded.redis.server
 
-import io.github.tobi.laa.spring.boot.embedded.redis.EmbeddedRedisSpringExtension
-import org.junit.jupiter.api.extension.ExtendWith
+import io.github.tobi.laa.spring.boot.embedded.redis.junit.extension.EmbeddedRedisTest
 import org.springframework.test.context.ContextCustomizerFactories
 import kotlin.reflect.KClass
 
@@ -11,7 +10,7 @@ import kotlin.reflect.KClass
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @MustBeDocumented
-@ExtendWith(EmbeddedRedisSpringExtension::class)
+@EmbeddedRedisTest
 @ContextCustomizerFactories(RedisServerContextCustomizerFactory::class)
 annotation class EmbeddedRedisServer(
     /**
@@ -22,6 +21,13 @@ annotation class EmbeddedRedisServer(
 
     /**
      * The path to the Redis config file to use. If set, the config will be loaded from the file.
+     *
+     * > **Warning**
+     * Due to how embedded Redis is implemented, a [port] specified in the `redis.conf` file will be ignored.
+     *
+     * > **Warning**
+     * Cannot be set together with [settings].
+     *
      * @see redis.embedded.core.RedisServerBuilder.configFile
      */
     val configFile: String = "",
@@ -34,6 +40,10 @@ annotation class EmbeddedRedisServer(
 
     /**
      * The setting to use. If set, the server will be started with the given settings.
+     *
+     * > **Warning**
+     * Cannot be set together with [configFile].
+     *
      * @see redis.embedded.core.RedisServerBuilder.setting
      */
     val settings: Array<String> = [],

src/main/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/shardedcluster/EmbeddedRedisShardedCluster.kt

@@ -1,3 +1,16 @@
 package io.github.tobi.laa.spring.boot.embedded.redis.shardedcluster
 
-annotation class EmbeddedRedisShardedCluster()
+import io.github.tobi.laa.spring.boot.embedded.redis.junit.extension.RedisFlushAllExtension
+import io.github.tobi.laa.spring.boot.embedded.redis.server.RedisServerContextCustomizerFactory
+import org.junit.jupiter.api.extension.ExtendWith
+import org.springframework.test.context.ContextCustomizerFactories
+
+/**
+ * Annotation to enable an [embedded Redis sharded cluster][redis.embedded.RedisShardedCluster] for tests.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+@ExtendWith(RedisFlushAllExtension::class)
+@ContextCustomizerFactories(RedisServerContextCustomizerFactory::class)
+annotation class EmbeddedRedisShardedCluster

src/test/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/RedisTests.kt

@@ -6,15 +6,18 @@ import org.assertj.core.api.ObjectAssert
 import org.springframework.boot.autoconfigure.data.redis.RedisProperties
 import org.springframework.context.ApplicationContext
 import org.springframework.context.ApplicationContextAware
+import org.springframework.context.annotation.Scope
 import org.springframework.data.redis.core.RedisTemplate
 import org.springframework.stereotype.Component
+import redis.embedded.Redis
 import java.util.*
 import kotlin.random.Random
 
 /**
  * Used for sharing common test logic across different test classes.
  */
 @Component
+@Scope("prototype")
 internal open class RedisTests(
     val props: RedisProperties,
     val template: RedisTemplate<String, Any>,

src/test/kotlin/io/github/tobi/laa/spring/boot/embedded/redis/server/ParamResolverTest.kt

@@ -0,0 +1,91 @@
+package io.github.tobi.laa.spring.boot.embedded.redis.server
+
+import io.github.tobi.laa.spring.boot.embedded.redis.IntegrationTest
+import io.github.tobi.laa.spring.boot.embedded.redis.RedisStore
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.*
+import org.springframework.context.ApplicationContext
+import redis.embedded.Redis
+import redis.embedded.RedisInstance
+import redis.embedded.RedisServer
+
+@IntegrationTest
+@EmbeddedRedisServer
+@DisplayName("Parameter resolver test for @EmbeddedRedisServer")
+internal class ParamResolverTest {
+
+    var paramsFromBeforeEach = listOf<Redis>()
+    var paramsFromAfterEach = listOf<Redis>()
+
+    @Test
+    @Order(1)
+    @DisplayName("Should resolve @Test parameters correctly")
+    fun shouldResolveTestParamsCorrectly(redis: Redis, redisServer: RedisServer, redisInstance: RedisInstance) {
+        thenParamIsCorrectlyResolved(redis)
+        thenParamIsCorrectlyResolved(redisServer)
+        thenParamIsCorrectlyResolved(redisInstance)
+    }
+
+    @BeforeEach
+    fun beforeEach(redis: Redis, redisServer: RedisServer, redisInstance: RedisInstance) {
+        paramsFromBeforeEach = listOf(redis, redisServer, redisInstance)
+    }
+
+    @Test
+    @Order(2)
+    @DisplayName("Should resolve @BeforeEach params correctly")
+    fun shouldResolveBeforeEachParamsCorrectly() {
+        paramsFromBeforeEach.forEach { thenParamIsCorrectlyResolved(it) }
+    }
+
+    @Test
+    @Order(3)
+    @DisplayName("Should resolve @BeforeAll params correctly")
+    fun shouldResolveBeforeAllParamsCorrectly() {
+        paramsFromBeforeAll.forEach { thenParamIsCorrectlyResolved(it) }
+    }
+
+    @AfterEach
+    fun afterEach(redis: Redis, redisServer: RedisServer, redisInstance: RedisInstance) {
+        paramsFromAfterEach = listOf(redis, redisServer, redisInstance)
+    }
+
+    @Test
+    @Order(4)
+    @DisplayName("Should resolve @AfterEach params correctly")
+    fun shouldResolveAfterEachParamsCorrectly() {
+        paramsFromAfterEach.forEach { thenParamIsCorrectlyResolved(it) }
+    }
+
+    private companion object {
+
+        var paramsFromBeforeAll = listOf<Redis>()
+
+        var context: ApplicationContext? = null
+
+        @JvmStatic
+        @BeforeAll
+        fun injectContext(context: ApplicationContext) {
+            this.context = context
+        }
+
+        @JvmStatic
+        @BeforeAll
+        fun beforeAll(redis: Redis, redisServer: RedisServer, redisInstance: RedisInstance) {
+            paramsFromBeforeAll = listOf(redis, redisServer, redisInstance)
+        }
+
+        @JvmStatic
+        @AfterAll
+        fun afterAll(redis: Redis, redisServer: RedisServer, redisInstance: RedisInstance) {
+            // no @Test methods will be executed after this method, so assertions are put here instead
+            thenParamIsCorrectlyResolved(redis)
+            thenParamIsCorrectlyResolved(redisServer)
+            thenParamIsCorrectlyResolved(redisInstance)
+        }
+
+        private fun thenParamIsCorrectlyResolved(param: Any?) {
+            Assertions.assertThat(param).isNotNull.isEqualTo(RedisStore.server(context!!)!!)
+        }
+    }
+}