added modules container

Author: jruaux

build.gradle

@@ -26,7 +26,7 @@ repositories {
 dependencies {
     compileOnly group: 'org.projectlombok', name: 'lombok', version: lombok_version
     annotationProcessor group: 'org.projectlombok', name: 'lombok', version: lombok_version
-    implementation 'io.lettuce:lettuce-core:6.1.1.RELEASE'
+    implementation 'com.redislabs:mesclun:1.2.1'
     api 'org.junit.jupiter:junit-jupiter-api'
     api 'org.junit.jupiter:junit-jupiter-engine'
     api 'org.junit.jupiter:junit-jupiter-params'

src/main/java/com/redislabs/testcontainers/BaseRedisModulesTest.java

@@ -1,5 +1,8 @@
 package com.redislabs.testcontainers;
 
+import com.redislabs.mesclun.RedisModulesAsyncCommands;
+import com.redislabs.mesclun.RedisModulesCommands;
+import com.redislabs.mesclun.RedisModulesReactiveCommands;
 import io.lettuce.core.api.async.BaseRedisAsyncCommands;
 import io.lettuce.core.api.reactive.BaseRedisReactiveCommands;
 import io.lettuce.core.api.sync.BaseRedisCommands;
@@ -18,36 +21,30 @@ public class BaseRedisModulesTest {
     @Container
     protected static final RedisModulesContainer REDIS = new RedisModulesContainer();
 
-    @Container
-    protected static final RedisModulesContainer REDIS_CLUSTER = new RedisModulesContainer().withClusterMode();
-
     @BeforeAll
     static void isRunning() {
         Assertions.assertTrue(REDIS.isRunning());
-        Assertions.assertTrue(REDIS_CLUSTER.isRunning());
     }
 
     @AfterEach
     public void cleanupEach() {
         RedisServerCommands<String, String> redisCommands = REDIS.sync();
         redisCommands.flushall();
-        RedisServerCommands<String, String> redisClusterCommands = REDIS_CLUSTER.sync();
-        redisClusterCommands.flushall();
     }
 
-    static Stream<RedisContainer> containers() {
-        return Stream.of(REDIS, REDIS_CLUSTER);
+    static Stream<RedisModulesContainer> containers() {
+        return Stream.of(REDIS);
     }
 
-    static Stream<BaseRedisCommands<String, String>> sync() {
+    static Stream<RedisModulesCommands<String, String>> sync() {
         return containers().map(RedisContainer::sync);
     }
 
-    static Stream<BaseRedisAsyncCommands<String, String>> async() {
+    static Stream<RedisModulesAsyncCommands<String, String>> async() {
         return containers().map(RedisContainer::async);
     }
 
-    static Stream<BaseRedisReactiveCommands<String, String>> reactive() {
+    static Stream<RedisModulesReactiveCommands<String, String>> reactive() {
         return containers().map(RedisContainer::reactive);
     }
 

src/main/java/com/redislabs/testcontainers/RedisContainer.java

@@ -27,7 +27,7 @@ public class RedisContainer extends GenericContainer<RedisContainer> {
 
     public static final int REDIS_PORT = 6379;
 
-    private boolean cluster;
+    protected boolean cluster;
 
     public RedisContainer() {
         this(DEFAULT_IMAGE_NAME.withTag(DEFAULT_TAG));

src/main/java/com/redislabs/testcontainers/RedisModulesContainer.java

@@ -1,7 +1,11 @@
 package com.redislabs.testcontainers;
 
+import com.redislabs.mesclun.RedisModulesClient;
+import io.lettuce.core.api.StatefulConnection;
 import org.testcontainers.utility.DockerImageName;
 
+import java.util.function.Supplier;
+
 public class RedisModulesContainer extends RedisContainer {
 
     private static final DockerImageName DEFAULT_IMAGE_NAME = DockerImageName.parse("redislabs/redismod");
@@ -19,4 +23,12 @@ public RedisModulesContainer(final DockerImageName dockerImageName) {
     protected DockerImageName defaultImageName() {
         return DEFAULT_IMAGE_NAME;
     }
+
+    @Override
+    public Supplier<StatefulConnection<String, String>> connectionSupplier() {
+        if (cluster) {
+            throw new UnsupportedOperationException("Redis Modules container does not support cluster mode");
+        }
+        return RedisModulesClient.create(redisUri())::connect;
+    }
 }

src/test/java/com/redislabs/testcontainers/TestRedisModulesContainer.java

@@ -0,0 +1,47 @@
+package com.redislabs.testcontainers;
+
+import com.redislabs.mesclun.gears.RedisGearsCommands;
+import com.redislabs.mesclun.gears.output.ExecutionResults;
+import com.redislabs.mesclun.timeseries.CreateOptions;
+import com.redislabs.mesclun.timeseries.Label;
+import com.redislabs.mesclun.timeseries.RedisTimeSeriesCommands;
+import io.lettuce.core.api.sync.BaseRedisCommands;
+import io.lettuce.core.api.sync.RedisHashCommands;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Testcontainers
+public class TestRedisModulesContainer extends BaseRedisModulesTest {
+
+
+    @ParameterizedTest(name = "can ping {0}")
+    @MethodSource("containers")
+    void canPing(RedisModulesContainer redisContainer) {
+        BaseRedisCommands<String, String> commands = redisContainer.sync();
+        Assertions.assertEquals("PONG", commands.ping());
+    }
+
+    @ParameterizedTest(name = "can execute RedisGears function on {0}")
+    @MethodSource("containers")
+    void canExecuteRedisGearsFunction(RedisModulesContainer redisContainer) {
+        RedisGearsCommands<String, String> gears = redisContainer.sync();
+        ExecutionResults results = gears.pyExecute("GB().run()");
+        Assertions.assertTrue(results.isOk());
+    }
+
+    @ParameterizedTest(name = "can write to RedisTimeSeries at {0}")
+    @MethodSource("containers")
+    void canWriteToRedisTimeSeries(RedisModulesContainer redisContainer) {
+        RedisTimeSeriesCommands<String, String> ts = redisContainer.sync();
+        ts.create("temperature:3:11", CreateOptions.builder().retentionTime(6000).build(), Label.of("sensor_id", "2"), Label.of("area_id", "32"));
+        // TS.ADD temperature:3:11 1548149181 30
+        Long add1 = ts.add("temperature:3:11", 1548149181, 30);
+        Assertions.assertEquals(1548149181, add1);
+    }
+
+}