Added junit-jupiter project

Author: jruaux

build.gradle

@@ -48,6 +48,12 @@ config {
     }
 }
 
+eclipse {
+    project {
+        name = 'testcontainers-redis-root'
+    }
+}
+
 allprojects {
     repositories {
         gradlePluginPortal()

settings.gradle

@@ -32,10 +32,7 @@ projects {
 }
 
 enforce {
-    mergeStrategy = 'append'
+   
+    enabled = false    
 
-    rule(enforcer.rules.ForceDependencies) { r ->
-        r.dependencies.addAll "org.slf4j:slf4j-api:1.7.30",
-        "org.junit.jupiter:junit-jupiter-api:5.7.2"
-    }
 }

subprojects/testcontainers-redis-junit-jupiter/bin/main/com/redis/testcontainers/junit/jupiter/AbstractTestcontainersRedisTestBase.class

@@ -0,0 +1 @@
+project_description = "Testcontainers Redis :: JUnit Jupiter Extension"

subprojects/testcontainers-redis-junit-jupiter/bin/main/com/redis/testcontainers/junit/jupiter/RedisTestContext.class

@@ -0,0 +1,59 @@
+package com.redis.testcontainers.junit.jupiter;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import com.redis.testcontainers.RedisServer;
+
+/**
+ * <code>
+ * 
+ * &#64;ParameterizedTest
+ * &#64;RedisTestContextsSource
+ * void myTest(RedisTestContext redis) {
+ *    ...
+ * }
+ * </code>
+ * 
+ * @author jruaux
+ *
+ */
+@Testcontainers
+@TestInstance(Lifecycle.PER_CLASS)
+public abstract class AbstractTestcontainersRedisTestBase {
+
+	private Collection<RedisTestContext> contexts;
+
+	protected abstract Collection<RedisServer> servers();
+
+	protected Collection<RedisTestContext> getContexts() {
+		return contexts;
+	}
+
+	@BeforeAll
+	protected void setupContexts() {
+		contexts = servers().stream().map(RedisTestContext::new).collect(Collectors.toList());
+	}
+
+	@BeforeEach
+	protected void flushAll() {
+		contexts.forEach(c -> {
+			c.sync().flushall();
+			Awaitility.await().until(() -> c.sync().dbsize() == 0);
+		});
+	}
+
+	@AfterAll
+	protected void teardownContexts() {
+		contexts.forEach(RedisTestContext::close);
+	}
+
+}

subprojects/testcontainers-redis-junit-jupiter/bin/main/com/redis/testcontainers/junit/jupiter/RedisTestContextsProvider.class

@@ -0,0 +1,107 @@
+package com.redis.testcontainers.junit.jupiter;
+
+import com.redis.lettucemod.RedisModulesClient;
+import com.redis.lettucemod.api.StatefulRedisModulesConnection;
+import com.redis.lettucemod.api.async.RedisModulesAsyncCommands;
+import com.redis.lettucemod.api.reactive.RedisModulesReactiveCommands;
+import com.redis.lettucemod.api.sync.RedisModulesCommands;
+import com.redis.lettucemod.cluster.RedisModulesClusterClient;
+import com.redis.testcontainers.RedisServer;
+
+import io.lettuce.core.AbstractRedisClient;
+import io.lettuce.core.RedisClient;
+import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
+
+public class RedisTestContext implements AutoCloseable {
+
+	private final RedisServer server;
+	private final AbstractRedisClient client;
+	private StatefulRedisModulesConnection<String, String> connection;
+	private StatefulRedisPubSubConnection<String, String> pubSubConnection;
+
+	public RedisTestContext(RedisServer server) {
+		this.server = server;
+		this.client = client(server);
+	}
+
+	private AbstractRedisClient client(RedisServer server) {
+		if (server.isCluster()) {
+			return RedisModulesClusterClient.create(server.getRedisURI());
+		}
+		return RedisModulesClient.create(server.getRedisURI());
+	}
+
+	public RedisServer getServer() {
+		return server;
+	}
+
+	public AbstractRedisClient getClient() {
+		return client;
+	}
+
+	public StatefulRedisModulesConnection<String, String> getConnection() {
+		if (connection == null) {
+			this.connection = connection();
+		}
+		return connection;
+	}
+
+	public StatefulRedisPubSubConnection<String, String> getPubSubConnection() {
+		if (pubSubConnection == null) {
+			pubSubConnection = pubSubConnection();
+		}
+		return pubSubConnection;
+	}
+
+	private StatefulRedisModulesConnection<String, String> connection() {
+		if (client instanceof RedisModulesClusterClient) {
+			return ((RedisModulesClusterClient) client).connect();
+		}
+		return ((RedisModulesClient) client).connect();
+	}
+
+	private StatefulRedisPubSubConnection<String, String> pubSubConnection() {
+		if (client instanceof RedisModulesClusterClient) {
+			return ((RedisModulesClusterClient) client).connectPubSub();
+		}
+		return ((RedisModulesClient) client).connectPubSub();
+	}
+
+	public RedisModulesCommands<String, String> sync() {
+		return getConnection().sync();
+	}
+
+	public RedisModulesAsyncCommands<String, String> async() {
+		return getConnection().async();
+	}
+
+	public RedisModulesReactiveCommands<String, String> reactive() {
+		return getConnection().reactive();
+	}
+
+	@Override
+	public void close() {
+		if (pubSubConnection != null) {
+			pubSubConnection.close();
+		}
+		if (connection != null) {
+			connection.close();
+		}
+		client.shutdown();
+		client.getResources().shutdown();
+	}
+
+	public RedisClient getRedisClient() {
+		return (RedisClient) client;
+	}
+
+	public RedisClusterClient getRedisClusterClient() {
+		return (RedisClusterClient) client;
+	}
+
+	public boolean isCluster() {
+		return client instanceof RedisClusterClient;
+	}
+
+}

subprojects/testcontainers-redis-junit-jupiter/bin/main/com/redis/testcontainers/junit/jupiter/RedisTestContextsSource.class

@@ -0,0 +1,17 @@
+package com.redis.testcontainers.junit.jupiter;
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+
+class RedisTestContextsProvider implements ArgumentsProvider {
+
+	@Override
+	public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
+		AbstractTestcontainersRedisTestBase instance = (AbstractTestcontainersRedisTestBase) context.getRequiredTestInstance();
+		return instance.getContexts().stream().map(Arguments::of);
+	}
+
+}