You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by es...@apache.org on 2021/05/14 19:32:33 UTC
[geode] branch develop updated: GEODE-9220: Switch String
integration tests to use JedisCluster. (#6444)
This is an automated email from the ASF dual-hosted git repository.
eshu11 pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 78e5016 GEODE-9220: Switch String integration tests to use JedisCluster. (#6444)
78e5016 is described below
commit 78e50166bb0f88e8406ab00fc01db25ac4df33fe
Author: Eric Shu <es...@pivotal.io>
AuthorDate: Fri May 14 12:31:06 2021 -0700
GEODE-9220: Switch String integration tests to use JedisCluster. (#6444)
* Create separate test for Redis memory info for append testing, as it is not supported
in cluster mode.
---
... => AppendMemoryNativeRedisAcceptanceTest.java} | 5 +-
.../string/AppendNativeRedisAcceptanceTest.java | 12 +-
.../string/BitCountNativeRedisAcceptanceTest.java | 10 +-
.../string/BitOpNativeRedisAcceptanceTest.java | 10 +-
.../string/DecrByNativeRedisAcceptanceTest.java | 10 +-
.../string/DecrNativeRedisAcceptanceTest.java | 10 +-
.../string/GetBitNativeRedisAcceptanceTest.java | 10 +-
.../string/GetNativeRedisAcceptanceTest.java | 10 +-
.../string/GetRangeNativeRedisAcceptanceTest.java | 10 +-
.../string/GetSetNativeRedisAcceptanceTest.java | 10 +-
.../IncrByFloatNativeRedisAcceptanceTest.java | 10 +-
.../string/IncrByNativeRedisAcceptanceTest.java | 10 +-
.../string/IncrNativeRedisAcceptanceTest.java | 10 +-
.../string/MGetNativeRedisAcceptanceTest.java | 10 +-
.../string/MSetNXNativeRedisAcceptanceTest.java | 10 +-
.../string/MSetNativeRedisAcceptanceTest.java | 10 +-
.../string/PSetEXNativeRedisAcceptanceTest.java | 10 +-
.../string/SetBitNativeRedisAcceptanceTest.java | 10 +-
.../string/SetExNativeRedisAcceptanceTest.java | 10 +-
.../string/SetNXNativeRedisAcceptanceTest.java | 10 +-
.../string/SetNativeRedisAcceptanceTest.java | 10 +-
.../string/SetRangeNativeRedisAcceptanceTest.java | 10 +-
.../string/StringNativeRedisAcceptanceTest.java | 10 +-
.../apache/geode/redis/RedisIntegrationTest.java | 6 +-
.../string/AbstractAppendIntegrationTest.java | 59 ++-------
...va => AbstractAppendMemoryIntegrationTest.java} | 58 +++++----
.../string/AbstractBitCountIntegrationTest.java | 9 +-
.../string/AbstractBitOpIntegrationTest.java | 83 ++++++------
.../string/AbstractDecrByIntegrationTest.java | 33 ++---
.../string/AbstractDecrIntegrationTest.java | 14 +-
.../string/AbstractGetBitIntegrationTest.java | 9 +-
.../string/AbstractGetIntegrationTest.java | 9 +-
.../string/AbstractGetRangeIntegrationTest.java | 47 ++++---
.../string/AbstractGetSetIntegrationTest.java | 20 +--
.../string/AbstractIncrByFloatIntegrationTest.java | 72 +++++-----
.../string/AbstractIncrByIntegrationTest.java | 20 ++-
.../string/AbstractIncrIntegrationTest.java | 14 +-
.../AbstractLettuceAppendIntegrationTest.java | 14 +-
.../string/AbstractMGetIntegrationTest.java | 36 ++---
.../string/AbstractMSetIntegrationTest.java | 28 ++--
.../string/AbstractMSetNXIntegrationTest.java | 20 +--
.../string/AbstractPSetEXIntegrationTest.java | 9 +-
.../string/AbstractSetBitIntegrationTest.java | 11 +-
.../string/AbstractSetEXIntegrationTest.java | 11 +-
.../string/AbstractSetIntegrationTest.java | 145 ++++++++-------------
.../string/AbstractSetNXIntegrationTest.java | 23 ++--
.../string/AbstractSetRangeIntegrationTest.java | 9 +-
.../string/AbstractStringIntegrationTest.java | 11 +-
.../string/AppendMemoryIntegrationTest.java} | 8 +-
49 files changed, 517 insertions(+), 488 deletions(-)
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryNativeRedisAcceptanceTest.java
old mode 100755
new mode 100644
similarity index 91%
copy from geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
copy to geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryNativeRedisAcceptanceTest.java
index 8c3a9ee..560d0af
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryNativeRedisAcceptanceTest.java
@@ -14,13 +14,11 @@
*/
package org.apache.geode.redis.internal.executor.string;
-
import org.junit.ClassRule;
import org.apache.geode.NativeRedisTestRule;
-public class AppendNativeRedisAcceptanceTest extends AbstractAppendIntegrationTest {
-
+public class AppendMemoryNativeRedisAcceptanceTest extends AbstractAppendMemoryIntegrationTest {
@ClassRule
public static NativeRedisTestRule server = new NativeRedisTestRule();
@@ -28,4 +26,5 @@ public class AppendNativeRedisAcceptanceTest extends AbstractAppendIntegrationTe
public int getPort() {
return server.getPort();
}
+
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
index 8c3a9ee..06c5829 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
@@ -14,18 +14,22 @@
*/
package org.apache.geode.redis.internal.executor.string;
-
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class AppendNativeRedisAcceptanceTest extends AbstractAppendIntegrationTest {
@ClassRule
- public static NativeRedisTestRule server = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule server = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return server.getPort();
+ return server.getExposedPorts().get(0);
+ }
+
+ @Override
+ public void flushAll() {
+ server.flushAll();
}
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitCountNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitCountNativeRedisAcceptanceTest.java
index bd85f4a..97d82a7 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitCountNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitCountNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class BitCountNativeRedisAcceptanceTest extends AbstractBitCountIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitOpNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitOpNativeRedisAcceptanceTest.java
index b2a0692..54b1fc4 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitOpNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/BitOpNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class BitOpNativeRedisAcceptanceTest extends AbstractBitOpIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrByNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrByNativeRedisAcceptanceTest.java
index aae65be..92deae1 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrByNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrByNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class DecrByNativeRedisAcceptanceTest extends AbstractDecrByIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrNativeRedisAcceptanceTest.java
index e4cffc1..5605df0 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/DecrNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class DecrNativeRedisAcceptanceTest extends AbstractDecrIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetBitNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetBitNativeRedisAcceptanceTest.java
index a6905b1..e2cb303 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetBitNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetBitNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class GetBitNativeRedisAcceptanceTest extends AbstractGetBitIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetNativeRedisAcceptanceTest.java
index e6cfc26..40d7c9b 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class GetNativeRedisAcceptanceTest extends AbstractGetIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetRangeNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetRangeNativeRedisAcceptanceTest.java
index a3b6966..928bbd2 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetRangeNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetRangeNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class GetRangeNativeRedisAcceptanceTest extends AbstractGetRangeIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetSetNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetSetNativeRedisAcceptanceTest.java
index 7911d52..6b783e4 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetSetNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/GetSetNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class GetSetNativeRedisAcceptanceTest extends AbstractGetSetIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByFloatNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByFloatNativeRedisAcceptanceTest.java
index 252991c..8e9d763 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByFloatNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByFloatNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class IncrByFloatNativeRedisAcceptanceTest extends AbstractIncrByFloatIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByNativeRedisAcceptanceTest.java
index 4c46805..1c3d591 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrByNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class IncrByNativeRedisAcceptanceTest extends AbstractIncrByIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrNativeRedisAcceptanceTest.java
index 3a26267..3a7052b 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/IncrNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class IncrNativeRedisAcceptanceTest extends AbstractIncrIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MGetNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MGetNativeRedisAcceptanceTest.java
index c5072e9..a8fe58d 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MGetNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MGetNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class MGetNativeRedisAcceptanceTest extends AbstractMGetIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNXNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNXNativeRedisAcceptanceTest.java
index 55d71ac..d3fd28c 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNXNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNXNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class MSetNXNativeRedisAcceptanceTest extends AbstractMSetNXIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNativeRedisAcceptanceTest.java
index 01f30e4..fe1d6b9 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/MSetNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class MSetNativeRedisAcceptanceTest extends AbstractMSetIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/PSetEXNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/PSetEXNativeRedisAcceptanceTest.java
index 59f5471..d502ca1 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/PSetEXNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/PSetEXNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class PSetEXNativeRedisAcceptanceTest extends AbstractPSetEXIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetBitNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetBitNativeRedisAcceptanceTest.java
index b683424..be3ce27 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetBitNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetBitNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class SetBitNativeRedisAcceptanceTest extends AbstractSetBitIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetExNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetExNativeRedisAcceptanceTest.java
index ce6c818..dfa4814 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetExNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetExNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class SetExNativeRedisAcceptanceTest extends AbstractSetEXIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNXNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNXNativeRedisAcceptanceTest.java
index d0b68ac..9524b22 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNXNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNXNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class SetNXNativeRedisAcceptanceTest extends AbstractSetNXIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNativeRedisAcceptanceTest.java
index 455e5cb..38c06ff 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetNativeRedisAcceptanceTest.java
@@ -16,16 +16,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class SetNativeRedisAcceptanceTest extends AbstractSetIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetRangeNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetRangeNativeRedisAcceptanceTest.java
index 9791b42..0bd881e 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetRangeNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/SetRangeNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class SetRangeNativeRedisAcceptanceTest extends AbstractSetRangeIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/StringNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/StringNativeRedisAcceptanceTest.java
index c25932e..f3531d9 100755
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/StringNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/StringNativeRedisAcceptanceTest.java
@@ -17,16 +17,20 @@ package org.apache.geode.redis.internal.executor.string;
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
+import org.apache.geode.redis.NativeRedisClusterTestRule;
public class StringNativeRedisAcceptanceTest extends AbstractStringIntegrationTest {
@ClassRule
- public static NativeRedisTestRule redis = new NativeRedisTestRule();
+ public static NativeRedisClusterTestRule redis = new NativeRedisClusterTestRule();
@Override
public int getPort() {
- return redis.getPort();
+ return redis.getExposedPorts().get(0);
}
+ @Override
+ public void flushAll() {
+ redis.flushAll();
+ }
}
diff --git a/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/redis/RedisIntegrationTest.java b/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/redis/RedisIntegrationTest.java
index 7157886..3c99d0c 100644
--- a/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/redis/RedisIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/redis/RedisIntegrationTest.java
@@ -17,12 +17,16 @@ package org.apache.geode.redis;
import redis.clients.jedis.Jedis;
+import org.apache.geode.test.awaitility.GeodeAwaitility;
+
public interface RedisIntegrationTest {
int getPort();
+ int REDIS_CLIENT_TIMEOUT = Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
+
default void flushAll() {
- try (Jedis jedis = new Jedis("localhost", getPort())) {
+ try (Jedis jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT)) {
jedis.flushAll();
}
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendIntegrationTest.java
index bfc811a..0527081 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendIntegrationTest.java
@@ -20,32 +20,32 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import org.apache.geode.redis.ConcurrentLoopingThreads;
import org.apache.geode.redis.RedisIntegrationTest;
+import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractAppendIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
+ private static final int REDIS_CLIENT_TIMEOUT =
+ Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), 10000000);
- jedis2 = new Jedis("localhost", getPort(), 10000000);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
- public void flushAll() {
- jedis.flushAll();
+ public void tearDown() {
+ flushAll();
jedis.close();
}
@@ -81,7 +81,7 @@ public abstract class AbstractAppendIntegrationTest implements RedisIntegrationT
new ConcurrentLoopingThreads(listSize,
(i) -> jedis.append(key, values1.get(i)),
- (i) -> jedis2.append(key, values2.get(i))).run();
+ (i) -> jedis.append(key, values2.get(i))).run();
for (int i = 0; i < listSize; i++) {
assertThat(jedis.get(key)).contains(values1.get(i));
@@ -107,26 +107,6 @@ public abstract class AbstractAppendIntegrationTest implements RedisIntegrationT
}
@Test
- public void testAppend_actuallyIncreasesBucketSize() {
- int listSize = 1000;
- String key = "key";
-
- Map<String, String> info = getInfo(jedis);
- Long previousMemValue = Long.valueOf(info.get("used_memory"));
-
- jedis.set(key, "initial");
- for (int i = 0; i < listSize; i++) {
- jedis.append(key, "morestuff");
- }
-
- info = getInfo(jedis);
- Long finalMemValue = Long.valueOf(info.get("used_memory"));
-
-
- assertThat(finalMemValue).isGreaterThan(previousMemValue);
- }
-
- @Test
public void testAppend_withUTF16KeyAndValue() throws IOException {
String test_utf16_string = "最𐐷𤭢";
byte[] testBytes = test_utf16_string.getBytes(StandardCharsets.UTF_16);
@@ -153,23 +133,4 @@ public abstract class AbstractAppendIntegrationTest implements RedisIntegrationT
}
return strings;
}
-
- /**
- * Convert the values returned by the INFO command into a basic param:value map.
- */
- static Map<String, String> getInfo(Jedis jedis) {
- Map<String, String> results = new HashMap<>();
- String rawInfo = jedis.info();
-
- for (String line : rawInfo.split("\r\n")) {
- int colonIndex = line.indexOf(":");
- if (colonIndex > 0) {
- String key = line.substring(0, colonIndex);
- String value = line.substring(colonIndex + 1);
- results.put(key, value);
- }
- }
-
- return results;
- }
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendMemoryIntegrationTest.java
old mode 100755
new mode 100644
similarity index 54%
copy from geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java
copy to geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendMemoryIntegrationTest.java
index e59ff62..a2a09bf
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractAppendMemoryIntegrationTest.java
@@ -14,21 +14,20 @@
*/
package org.apache.geode.redis.internal.executor.string;
-import static org.apache.geode.redis.RedisCommandArgumentsTestHelper.assertExactNumberOfArgs;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.HashMap;
+import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
-import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
import org.apache.geode.test.awaitility.GeodeAwaitility;
-public abstract class AbstractSetEXIntegrationTest implements RedisIntegrationTest {
-
+public abstract class AbstractAppendMemoryIntegrationTest implements RedisIntegrationTest {
private Jedis jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@@ -39,33 +38,46 @@ public abstract class AbstractSetEXIntegrationTest implements RedisIntegrationTe
}
@After
- public void tearDown() {
+ public void flushAll() {
jedis.flushAll();
jedis.close();
}
@Test
- public void testSetEX() {
- jedis.setex("key", 20, "value");
+ public void testAppend_actuallyIncreasesBucketSize() {
+ int listSize = 1000;
+ String key = "key";
- assertThat(jedis.ttl("key")).isGreaterThanOrEqualTo(15);
- }
+ Map<String, String> info = getInfo(jedis);
+ Long previousMemValue = Long.valueOf(info.get("used_memory"));
- @Test
- public void errors_givenWrongNumberOfArguments() {
- assertExactNumberOfArgs(jedis, Protocol.Command.SETEX, 3);
- }
+ jedis.set(key, "initial");
+ for (int i = 0; i < listSize; i++) {
+ jedis.append(key, "morestuff");
+ }
- @Test
- public void givenMoreThanFourArgumentsProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.SETEX, "key", "10", "value", "extraArg"))
- .hasMessageContaining("ERR wrong number of arguments for 'setex' command");
+ info = getInfo(jedis);
+ Long finalMemValue = Long.valueOf(info.get("used_memory"));
+
+ assertThat(finalMemValue).isGreaterThan(previousMemValue);
}
- @Test
- public void testSetEXWithIllegalSeconds() {
- assertThatThrownBy(() -> jedis.setex("key", -1, "value"))
- .hasMessage("ERR invalid expire time in setex");
+ /**
+ * Convert the values returned by the INFO command into a basic param:value map.
+ */
+ static Map<String, String> getInfo(Jedis jedis) {
+ Map<String, String> results = new HashMap<>();
+ String rawInfo = jedis.info();
+
+ for (String line : rawInfo.split("\r\n")) {
+ int colonIndex = line.indexOf(":");
+ if (colonIndex > 0) {
+ String key = line.substring(0, colonIndex);
+ String value = line.substring(colonIndex + 1);
+ results.put(key, value);
+ }
+ }
+
+ return results;
}
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitCountIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitCountIntegrationTest.java
index f7dbc7d..efe5a11 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitCountIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitCountIntegrationTest.java
@@ -21,7 +21,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -29,18 +30,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractBitCountIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitOpIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitOpIntegrationTest.java
index 237daf7..b5f24ce 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitOpIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractBitOpIntegrationTest.java
@@ -25,23 +25,33 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.BitOP;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
+import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
+ private static final int REDIS_CLIENT_TIMEOUT =
+ Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
+ private final String hashTag = "{111}";
+ private final String destKey = "destKey" + hashTag;
+ private final String srcKey = "srcKey" + hashTag;
+ private final String value = "value";
+ private final byte[] key = {1, '{', 111, '}'};
+ private final byte[] other = {2, '{', 111, '}'};
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), 10000000);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -53,64 +63,65 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitop_givenInvalidOperationType_returnsSyntaxError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.BITOP, "invalidOp", "destKey", "srcKey"))
- .hasMessageContaining(ERROR_SYNTAX);
+ () -> jedis.sendCommand(hashTag, Protocol.Command.BITOP, "invalidOp", destKey,
+ srcKey)).hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void bitop_givenSetFails() {
- jedis.sadd("foo", "m1");
- assertThatThrownBy(() -> jedis.bitop(BitOP.AND, "key", "foo"))
+ jedis.sadd(srcKey, "m1");
+ assertThatThrownBy(() -> jedis.bitop(BitOP.AND, destKey, srcKey))
.hasMessageContaining(ERROR_WRONG_TYPE);
- assertThatThrownBy(() -> jedis.bitop(BitOP.OR, "key", "foo"))
+ assertThatThrownBy(() -> jedis.bitop(BitOP.OR, destKey, srcKey))
.hasMessageContaining(ERROR_WRONG_TYPE);
- assertThatThrownBy(() -> jedis.bitop(BitOP.XOR, "key", "foo"))
+ assertThatThrownBy(() -> jedis.bitop(BitOP.XOR, destKey, srcKey))
.hasMessageContaining(ERROR_WRONG_TYPE);
- assertThatThrownBy(() -> jedis.bitop(BitOP.NOT, "key", "foo"))
+ assertThatThrownBy(() -> jedis.bitop(BitOP.NOT, destKey, srcKey))
.hasMessageContaining(ERROR_WRONG_TYPE);
}
@Test
public void bitopNOT_givenMoreThanOneSourceKey_returnsError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.BITOP, "NOT", "destKey", "srcKey", "srcKey2"))
- .hasMessageContaining(ERROR_BITOP_NOT);
+ () -> jedis.sendCommand(
+ hashTag, Protocol.Command.BITOP, "NOT", destKey, srcKey, "srcKey2" + hashTag))
+ .hasMessageContaining(ERROR_BITOP_NOT);
}
@Test
public void bitopNOT_givenNothingLeavesKeyUnset() {
- assertThat(jedis.bitop(BitOP.NOT, "key", "foo")).isEqualTo(0);
- assertThat(jedis.exists("key")).isFalse();
+ assertThat(jedis.bitop(BitOP.NOT, destKey, srcKey)).isEqualTo(0);
+ assertThat(jedis.exists(destKey)).isFalse();
}
@Test
public void bitopNOT_givenNothingDeletesKey() {
- jedis.set("key", "value");
- assertThat(jedis.bitop(BitOP.NOT, "key", "foo")).isEqualTo(0);
- assertThat(jedis.exists("key")).isFalse();
+ jedis.set(destKey, value);
+ assertThat(jedis.bitop(BitOP.NOT, destKey, srcKey)).isEqualTo(0);
+ assertThat(jedis.exists(destKey)).isFalse();
}
@Test
public void bitopNOT_givenNothingDeletesSet() {
- jedis.sadd("key", "value");
- assertThat(jedis.bitop(BitOP.NOT, "key", "foo")).isEqualTo(0);
- assertThat(jedis.exists("key")).isFalse();
+ jedis.sadd(destKey, value);
+ assertThat(jedis.bitop(BitOP.NOT, destKey, srcKey)).isEqualTo(0);
+ assertThat(jedis.exists(destKey)).isFalse();
}
@Test
public void bitopNOT_givenEmptyStringDeletesKey() {
- jedis.set("key", "value");
- jedis.set("foo", "");
- assertThat(jedis.bitop(BitOP.NOT, "key", "foo")).isEqualTo(0);
- assertThat(jedis.exists("key")).isFalse();
+ jedis.set(destKey, value);
+ jedis.set(srcKey, "");
+ assertThat(jedis.bitop(BitOP.NOT, destKey, srcKey)).isEqualTo(0);
+ assertThat(jedis.exists(destKey)).isFalse();
}
@Test
public void bitopNOT_givenEmptyStringDeletesSet() {
- jedis.sadd("key", "value");
- jedis.set("foo", "");
- assertThat(jedis.bitop(BitOP.NOT, "key", "foo")).isEqualTo(0);
- assertThat(jedis.exists("key")).isFalse();
+ jedis.sadd(destKey, value);
+ jedis.set(srcKey, "");
+ assertThat(jedis.bitop(BitOP.NOT, destKey, srcKey)).isEqualTo(0);
+ assertThat(jedis.exists(destKey)).isFalse();
}
@Test
@@ -126,8 +137,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopNOT_createsNonExistingKey() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
jedis.set(other, bytes);
assertThat(jedis.bitop(BitOP.NOT, key, other)).isEqualTo(1);
@@ -138,8 +147,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopAND_givenSelfAndOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
byte[] otherBytes = {-1};
jedis.set(key, bytes);
@@ -152,8 +159,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopAND_givenSelfAndLongerOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
byte[] otherBytes = {-1, 3};
jedis.set(key, bytes);
@@ -167,8 +172,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopOR_givenSelfAndOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
byte[] otherBytes = {8};
jedis.set(key, bytes);
@@ -181,8 +184,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopOR_givenSelfAndLongerOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
byte[] otherBytes = {-1, 3};
jedis.set(key, bytes);
@@ -196,8 +197,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopXOR_givenSelfAndOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {9};
byte[] otherBytes = {8};
jedis.set(key, bytes);
@@ -210,8 +209,6 @@ public abstract class AbstractBitOpIntegrationTest implements RedisIntegrationTe
@Test
public void bitopXOR_givenSelfAndLongerOther() {
- byte[] key = {1};
- byte[] other = {2};
byte[] bytes = {1};
byte[] otherBytes = {-1, 3};
jedis.set(key, bytes);
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrByIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrByIntegrationTest.java
index 6258c15..09de658 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrByIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrByIntegrationTest.java
@@ -26,7 +26,8 @@ import java.math.BigInteger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -34,19 +35,21 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractDecrByIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
+ private final String hashTag = "{111}";
+ private final String someKey = "someKey" + hashTag;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -101,14 +104,14 @@ public abstract class AbstractDecrByIntegrationTest implements RedisIntegrationT
@Test
public void shouldThrowArithmeticException_givenDecrbyMoreThanMaxLong() {
- jedis.set("somekey", "1");
+ jedis.set(someKey, "1");
BigInteger maxLongValue = new BigInteger(String.valueOf(Long.MAX_VALUE));
BigInteger biggerThanMaxLongValue = maxLongValue.add(new BigInteger("1"));
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.DECRBY,
- "somekey", String.valueOf(biggerThanMaxLongValue)))
+ () -> jedis.sendCommand(hashTag, Protocol.Command.DECRBY,
+ someKey, String.valueOf(biggerThanMaxLongValue)))
.hasMessageContaining(ERROR_NOT_INTEGER);
jedis.set("key", String.valueOf((Long.MIN_VALUE)));
@@ -117,14 +120,14 @@ public abstract class AbstractDecrByIntegrationTest implements RedisIntegrationT
@Test
public void shouldReturnArithmeticError_givenDecrbyLessThanMinLong() {
- jedis.set("somekey", "1");
+ jedis.set(someKey, "1");
BigInteger minLongValue = new BigInteger(String.valueOf(Long.MIN_VALUE));
BigInteger smallerThanMinLongValue = minLongValue.subtract(new BigInteger("1"));
assertThatThrownBy(
- () -> jedis.sendCommand(
- Protocol.Command.DECRBY, "somekey",
+ () -> jedis.sendCommand(hashTag,
+ Protocol.Command.DECRBY, someKey,
smallerThanMinLongValue.toString()))
.hasMessageContaining(ERROR_NOT_INTEGER);
}
@@ -133,11 +136,11 @@ public abstract class AbstractDecrByIntegrationTest implements RedisIntegrationT
public void shouldReturnOverflowError_givenDecrbyThatWouldResultInValueLessThanMinLong() {
BigInteger minLongValue = new BigInteger(String.valueOf(Long.MIN_VALUE));
- jedis.set("somekey", String.valueOf(minLongValue));
+ jedis.set(someKey, String.valueOf(minLongValue));
assertThatThrownBy(
- () -> jedis.sendCommand(
- Protocol.Command.DECRBY, "somekey",
+ () -> jedis.sendCommand(hashTag,
+ Protocol.Command.DECRBY, someKey,
"1"))
.hasMessageContaining(ERROR_OVERFLOW);
}
@@ -146,9 +149,9 @@ public abstract class AbstractDecrByIntegrationTest implements RedisIntegrationT
@Test
public void should_returnWrongTypeError_givenKeyContainsNonStringValue() {
- jedis.hset("key", "1", "1");
+ jedis.hset("setKey", "1", "1");
assertThatThrownBy(
- () -> jedis.decrBy("key", 1)).hasMessageContaining(ERROR_WRONG_TYPE);
+ () -> jedis.decrBy("setKey", 1)).hasMessageContaining(ERROR_WRONG_TYPE);
}
@Test
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrIntegrationTest.java
index 6067cd7..b255853 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractDecrIntegrationTest.java
@@ -20,7 +20,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -29,22 +30,19 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractDecrIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
- jedis2.close();
}
@Test
@@ -79,7 +77,7 @@ public abstract class AbstractDecrIntegrationTest implements RedisIntegrationTes
int ITERATION_COUNT = 4000;
new ConcurrentLoopingThreads(ITERATION_COUNT,
(i) -> jedis.decr("contestedKey"),
- (i) -> jedis2.decr("contestedKey"))
+ (i) -> jedis.decr("contestedKey"))
.run();
assertThat(jedis.get("contestedKey")).isEqualTo(Integer.toString(-2 * ITERATION_COUNT));
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetBitIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetBitIntegrationTest.java
index 518b058..21789b0 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetBitIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetBitIntegrationTest.java
@@ -21,7 +21,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -29,18 +30,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractGetBitIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetIntegrationTest.java
index 8484959..5178dae 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetIntegrationTest.java
@@ -22,7 +22,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -30,18 +31,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractGetIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetRangeIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetRangeIntegrationTest.java
index e53f1af..155d15c 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetRangeIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetRangeIntegrationTest.java
@@ -26,7 +26,8 @@ import java.util.Random;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -36,18 +37,20 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractGetRangeIntegrationTest implements RedisIntegrationTest {
private Random random = new Random();
- private Jedis jedis;
+ private JedisCluster jedis;
+ private final String key = "key";
+ private final String value = "value";
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -59,42 +62,43 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void givenStartIndexIsNotAnInteger_returnsNotIntegerError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.GETRANGE, "key", "NaN", "5"))
+ () -> jedis.sendCommand(key, Protocol.Command.GETRANGE, key, "NaN", "5"))
.hasMessageContaining(ERROR_NOT_INTEGER);
}
@Test
public void givenEndIndexIsNotAnInteger_returnsNotIntegerError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.GETRANGE, "key", "0", "NaN"))
+ () -> jedis.sendCommand(key, Protocol.Command.GETRANGE, key, "0", "NaN"))
.hasMessageContaining(ERROR_NOT_INTEGER);
}
@Test
public void givenRangeIsBiggerThanMinOrMax_returnsNotIntegerError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.GETRANGE, "key", "0", "9223372036854775808"))
- .hasMessage("ERR " + ERROR_NOT_INTEGER);
+ () -> jedis.sendCommand(key, Protocol.Command.GETRANGE, key, "0",
+ "9223372036854775808"))
+ .hasMessage("ERR " + ERROR_NOT_INTEGER);
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.GETRANGE, "key", "0", "-9223372036854775809"))
- .hasMessage("ERR " + ERROR_NOT_INTEGER);
+ () -> jedis.sendCommand(key, Protocol.Command.GETRANGE, key, "0",
+ "-9223372036854775809"))
+ .hasMessage("ERR " + ERROR_NOT_INTEGER);
}
@Test
public void givenWrongType_returnsWrongTypeError() {
- jedis.sadd("set", "value");
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.GETRANGE, "set", "0", "1"))
+ jedis.sadd("set", value);
+ assertThatThrownBy(() -> jedis.sendCommand("set", Protocol.Command.GETRANGE, "set", "0", "1"))
.hasMessage("WRONGTYPE " + ERROR_WRONG_TYPE);
- jedis.hset("hash", "field", "value");
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.GETRANGE, "hash", "0", "1"))
+ jedis.hset("hash", "field", value);
+ assertThatThrownBy(() -> jedis.sendCommand("hash", Protocol.Command.GETRANGE, "hash", "0", "1"))
.hasMessage("WRONGTYPE " + ERROR_WRONG_TYPE);
}
@Test
public void testGetRange_whenWholeRangeSpecified_returnsEntireValue() {
- String key = "key";
String valueWith19Characters = "abc123babyyouknowme";
jedis.set(key, valueWith19Characters);
@@ -109,7 +113,6 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void testGetRange_whenMoreThanWholeRangeSpecified_returnsEntireValue() {
- String key = "key";
String valueWith19Characters = "abc123babyyouknowme";
jedis.set(key, valueWith19Characters);
@@ -126,7 +129,6 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void testGetRange_whenValidSubrangeSpecified_returnsAppropriateSubstring() {
- String key = "key";
String valueWith19Characters = "abc123babyyouknowme";
jedis.set(key, valueWith19Characters);
@@ -225,7 +227,6 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void testGetRange_rangeIsInvalid_returnsEmptyString() {
- String key = "key";
String valueWith19Characters = "abc123babyyouknowme";
jedis.set(key, valueWith19Characters);
@@ -247,9 +248,6 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void testGetRange_rangePastEndOfValue_returnsEmptyString() {
- String key = "key";
- String value = "value";
-
jedis.set(key, value);
String range = jedis.getrange(key, 7, 14);
@@ -258,12 +256,11 @@ public abstract class AbstractGetRangeIntegrationTest implements RedisIntegratio
@Test
public void testConcurrentGetrange_whileUpdating() {
- Jedis jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis.set("key", "1");
+ jedis.set(key, "1");
new ConcurrentLoopingThreads(10000,
- (i) -> jedis.set("key", Integer.toString(random.nextInt(10000))),
- (i) -> Integer.parseInt(jedis2.getrange("key", 0, 5)))
+ (i) -> jedis.set(key, Integer.toString(random.nextInt(10000))),
+ (i) -> Integer.parseInt(jedis.getrange(key, 0, 5)))
.run();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetSetIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetSetIntegrationTest.java
index 297fdfd..1bb1c9f 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetSetIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractGetSetIntegrationTest.java
@@ -29,7 +29,8 @@ import java.util.concurrent.Future;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisDataException;
@@ -39,23 +40,20 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractGetSetIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
private static final int ITERATION_COUNT = 4000;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
- jedis2.close();
}
@Test
@@ -129,7 +127,7 @@ public abstract class AbstractGetSetIntegrationTest implements RedisIntegrationT
CountDownLatch latch = new CountDownLatch(1);
ExecutorService pool = Executors.newFixedThreadPool(2);
Callable<Integer> callable1 = () -> doABunchOfIncrs(jedis, latch);
- Callable<Integer> callable2 = () -> doABunchOfGetSets(jedis2, latch);
+ Callable<Integer> callable2 = () -> doABunchOfGetSets(jedis, latch);
Future<Integer> future1 = pool.submit(callable1);
Future<Integer> future2 = pool.submit(callable2);
@@ -139,7 +137,8 @@ public abstract class AbstractGetSetIntegrationTest implements RedisIntegrationT
assertThat(future1.get() + future2.get()).isEqualTo(2 * ITERATION_COUNT);
}
- private Integer doABunchOfIncrs(Jedis jedis, CountDownLatch latch) throws InterruptedException {
+ private Integer doABunchOfIncrs(JedisCluster jedis, CountDownLatch latch)
+ throws InterruptedException {
latch.await();
for (int i = 0; i < ITERATION_COUNT; i++) {
jedis.incr("contestedKey");
@@ -147,7 +146,8 @@ public abstract class AbstractGetSetIntegrationTest implements RedisIntegrationT
return ITERATION_COUNT;
}
- private Integer doABunchOfGetSets(Jedis jedis, CountDownLatch latch) throws InterruptedException {
+ private Integer doABunchOfGetSets(JedisCluster jedis, CountDownLatch latch)
+ throws InterruptedException {
int sum = 0;
latch.await();
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByFloatIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByFloatIntegrationTest.java
index d4001e9..d165a2c 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByFloatIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByFloatIntegrationTest.java
@@ -25,28 +25,30 @@ import java.util.concurrent.atomic.AtomicReference;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
import org.apache.geode.redis.RedisIntegrationTest;
+import org.apache.geode.redis.internal.RedisConstants;
import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegrationTest {
- private static final int JEDIS_TIMEOUT =
+ private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
- private Jedis jedis;
+ private JedisCluster jedis;
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), JEDIS_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -80,7 +82,7 @@ public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegra
jedis.set(key1, "5e2");
double incr1 = 2.0e4;
- jedis.sendCommand(Protocol.Command.INCRBYFLOAT, key1, "2.0e4");
+ jedis.sendCommand(key1, Protocol.Command.INCRBYFLOAT, key1, "2.0e4");
assertThat(Double.valueOf(jedis.get(key1))).isEqualTo(num1 + incr1);
}
@@ -89,7 +91,7 @@ public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegra
jedis.set("nan", "abc");
assertThatThrownBy(() -> jedis.incrByFloat("nan", 1))
- .hasMessage("ERR value is not a valid float");
+ .hasMessageContaining(RedisConstants.ERROR_NOT_A_VALID_FLOAT);
}
@Test
@@ -97,55 +99,58 @@ public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegra
jedis.sadd("set", "abc");
assertThatThrownBy(() -> jedis.incrByFloat("set", 1))
- .hasMessage("WRONGTYPE Operation against a key holding the wrong kind of value");
+ .hasMessageContaining(RedisConstants.ERROR_WRONG_TYPE);
}
@Test
public void testCorrectErrorIsReturned_whenIncrByIsInvalid() {
+ String key = "number";
double number1 = 1.4;
- jedis.set("number", "" + number1);
+ jedis.set(key, "" + number1);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", " a b c"))
- .hasMessage("ERR value is not a valid float");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, " a b c"))
+ .hasMessageContaining(RedisConstants.ERROR_NOT_A_VALID_FLOAT);
}
@Test
public void testIncrByFloat_withInfinityAndVariants() {
- jedis.set("number", "1.4");
+ String key = "number";
+ jedis.set(key, "1.4");
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "+inf"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "+inf"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "-inf"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "-inf"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "inf"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "inf"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "+infinity"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "+infinity"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "-infinity"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "-infinity"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "infinity"))
- .hasMessage("ERR increment would produce NaN or Infinity");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "infinity"))
+ .hasMessageContaining(RedisConstants.ERROR_NAN_OR_INFINITY);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "nan"))
- .hasMessage("ERR value is not a valid float");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "nan"))
+ .hasMessageContaining(RedisConstants.ERROR_NOT_A_VALID_FLOAT);
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "infant"))
- .hasMessage("ERR value is not a valid float");
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "infant"))
+ .hasMessageContaining(RedisConstants.ERROR_NOT_A_VALID_FLOAT);
}
@Test
public void testIncrByFloat_withReallyBigNumbers() {
+ String key = "number";
// max unsigned long long - 1
BigDecimal biggy = new BigDecimal("18446744073709551614");
- jedis.set("number", biggy.toPlainString());
+ jedis.set(key, biggy.toPlainString());
// Beyond this, native redis produces inconsistent results.
- Object rawResult = jedis.sendCommand(Protocol.Command.INCRBYFLOAT, "number", "1");
+ Object rawResult = jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, "1");
BigDecimal result = new BigDecimal(new String((byte[]) rawResult));
assertThat(result.toPlainString()).isEqualTo(biggy.add(BigDecimal.ONE).toPlainString());
@@ -155,7 +160,6 @@ public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegra
public void testConcurrentIncrByFloat_performsAllIncrByFloats() {
String key = "key";
Random random = new Random();
- Jedis jedis2 = new Jedis("localhost", getPort(), JEDIS_TIMEOUT);
AtomicReference<BigDecimal> expectedValue = new AtomicReference<>();
expectedValue.set(new BigDecimal(0));
@@ -166,16 +170,14 @@ public abstract class AbstractIncrByFloatIntegrationTest implements RedisIntegra
(i) -> {
BigDecimal increment = BigDecimal.valueOf(random.nextInt(37));
expectedValue.getAndUpdate(x -> x.add(increment));
- jedis.sendCommand(Protocol.Command.INCRBYFLOAT, key, increment.toPlainString());
+ jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, increment.toPlainString());
},
(i) -> {
BigDecimal increment = BigDecimal.valueOf(random.nextInt(37));
expectedValue.getAndUpdate(x -> x.add(increment));
- jedis2.sendCommand(Protocol.Command.INCRBYFLOAT, key, increment.toPlainString());
+ jedis.sendCommand(key, Protocol.Command.INCRBYFLOAT, key, increment.toPlainString());
}).run();
assertThat(new BigDecimal(jedis.get(key))).isEqualTo(expectedValue.get());
-
- jedis2.close();
}
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByIntegrationTest.java
index fa5e929..d23f6be 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrByIntegrationTest.java
@@ -26,7 +26,8 @@ import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -35,8 +36,7 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractIncrByIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis1;
- private Jedis jedis2;
+ private JedisCluster jedis1;
private Random rand;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@@ -45,16 +45,13 @@ public abstract class AbstractIncrByIntegrationTest implements RedisIntegrationT
public void setUp() {
rand = new Random();
- jedis1 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis1 = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis1.flushAll();
+ flushAll();
jedis1.close();
- jedis2.flushAll();
- jedis2.close();
}
@Test
@@ -64,8 +61,9 @@ public abstract class AbstractIncrByIntegrationTest implements RedisIntegrationT
@Test
public void testIncrBy_failsWhenPerformedOnNonIntegerValue() {
- jedis1.sadd("key", "member");
- assertThatThrownBy(() -> jedis1.incrBy("key", 1))
+ String key = "key";
+ jedis1.sadd(key, "member");
+ assertThatThrownBy(() -> jedis1.incrBy(key, 1))
.hasMessageContaining("WRONGTYPE Operation against a key holding the wrong kind of value");
}
@@ -123,7 +121,7 @@ public abstract class AbstractIncrByIntegrationTest implements RedisIntegrationT
(i) -> {
int increment = ThreadLocalRandom.current().nextInt(-50, 50);
expectedValue.addAndGet(increment);
- jedis2.incrBy(key, increment);
+ jedis1.incrBy(key, increment);
}).run();
assertThat(Integer.parseInt(jedis1.get(key))).isEqualTo(expectedValue.get());
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrIntegrationTest.java
index f335abc..abd45b8 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractIncrIntegrationTest.java
@@ -23,7 +23,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -32,22 +33,19 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractIncrIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
- jedis2.close();
}
@Test
@@ -104,7 +102,7 @@ public abstract class AbstractIncrIntegrationTest implements RedisIntegrationTes
int ITERATION_COUNT = 4000;
new ConcurrentLoopingThreads(ITERATION_COUNT,
(i) -> jedis.incr("contestedKey"),
- (i) -> jedis2.incr("contestedKey"))
+ (i) -> jedis.incr("contestedKey"))
.run();
assertThat(jedis.get("contestedKey")).isEqualTo(Integer.toString(2 * ITERATION_COUNT));
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractLettuceAppendIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractLettuceAppendIntegrationTest.java
index 9c8b4ba..cf164aa 100644
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractLettuceAppendIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractLettuceAppendIntegrationTest.java
@@ -17,9 +17,9 @@ package org.apache.geode.redis.internal.executor.string;
import static org.assertj.core.api.Assertions.assertThat;
-import io.lettuce.core.RedisClient;
-import io.lettuce.core.api.StatefulRedisConnection;
-import io.lettuce.core.api.sync.RedisCommands;
+import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
+import io.lettuce.core.cluster.api.sync.RedisClusterCommands;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
@@ -30,14 +30,14 @@ import org.apache.geode.test.junit.rules.ExecutorServiceRule;
public abstract class AbstractLettuceAppendIntegrationTest implements RedisIntegrationTest {
- protected RedisClient client;
+ protected RedisClusterClient client;
@ClassRule
public static ExecutorServiceRule executor = new ExecutorServiceRule();
@Before
public void before() {
- client = RedisClient.create("redis://localhost:" + getPort());
+ client = RedisClusterClient.create("redis://localhost:" + getPort());
}
@After
@@ -50,8 +50,8 @@ public abstract class AbstractLettuceAppendIntegrationTest implements RedisInteg
String test_utf16_string = "最𐐷𤭢";
String double_utf16_string = test_utf16_string + test_utf16_string;
- StatefulRedisConnection<String, String> redisConnection = client.connect();
- RedisCommands<String, String> syncCommands = redisConnection.sync();
+ StatefulRedisClusterConnection<String, String> redisConnection = client.connect();
+ RedisClusterCommands<String, String> syncCommands = redisConnection.sync();
syncCommands.set(test_utf16_string, test_utf16_string);
syncCommands.append(test_utf16_string, test_utf16_string);
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMGetIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMGetIntegrationTest.java
index feeed6e..629eb6f 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMGetIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMGetIntegrationTest.java
@@ -22,7 +22,8 @@ import java.util.stream.IntStream;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -31,18 +32,19 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractMGetIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
+ private final String hashTag = "{111}";
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -53,9 +55,9 @@ public abstract class AbstractMGetIntegrationTest implements RedisIntegrationTes
@Test
public void testMGet_requestNonexistentKey_respondsWithNil() {
- String key1 = "existingKey";
- String key2 = "notReallyAKey";
- String value1 = "theRealValue";
+ String key1 = "existingKey" + hashTag;
+ String key2 = "notReallyAKey" + hashTag;
+ String value1 = "theRealValue" + hashTag;
String[] keys = new String[2];
String[] expectedVals = new String[2];
keys[0] = key1;
@@ -70,26 +72,26 @@ public abstract class AbstractMGetIntegrationTest implements RedisIntegrationTes
@Test
public void testMget_returnsNil_forNonStringKey() {
- jedis.sadd("set", "a");
- jedis.hset("hash", "a", "b");
- jedis.set("string", "ok");
-
- assertThat(jedis.mget("set", "hash", "string"))
+ String setKey = "set" + hashTag;
+ String hashKey = "hash" + hashTag;
+ String stringKey = "string" + hashTag;
+ jedis.sadd(setKey, "a");
+ jedis.hset(hashKey, "a", "b");
+ jedis.set(stringKey, "ok");
+
+ assertThat(jedis.mget(setKey, hashKey, stringKey))
.containsExactly(null, null, "ok");
}
@Test
public void testMget_whileConcurrentUpdates() {
- Jedis jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
String[] keys = IntStream.range(0, 10)
- .mapToObj(x -> "key-" + x)
+ .mapToObj(x -> "key-" + x + hashTag)
.toArray(String[]::new);
// Should not result in any exceptions
new ConcurrentLoopingThreads(1000,
(i) -> jedis.set(keys[i % 10], "value-" + i),
- (i) -> jedis2.mget(keys)).run();
-
- jedis2.close();
+ (i) -> jedis.mget(keys)).run();
}
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetIntegrationTest.java
index a008590..9885f35 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetIntegrationTest.java
@@ -29,7 +29,8 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -37,34 +38,32 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractMSetIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
+ private final String hashTag = "{111}";
private static final int ITERATION_COUNT = 4000;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
- jedis2.close();
}
@Test
public void givenKeyNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.MSET))
+ assertThatThrownBy(() -> jedis.sendCommand("any", Protocol.Command.MSET))
.hasMessageContaining("ERR wrong number of arguments for 'mset' command");
}
@Test
public void givenValueNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.MSET, "key"))
+ assertThatThrownBy(() -> jedis.sendCommand("key", Protocol.Command.MSET, "key"))
.hasMessageContaining("ERR wrong number of arguments for 'mset' command");
}
@@ -72,8 +71,9 @@ public abstract class AbstractMSetIntegrationTest implements RedisIntegrationTes
public void givenEvenNumberOfArgumentsProvided_returnsWrongNumberOfArgumentsError() {
// Redis returns this message in this scenario: "ERR wrong number of arguments for MSET"
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.MSET, "key1", "value1", "key2", "value2", "key3"))
- .hasMessageContaining("ERR wrong number of arguments");
+ () -> jedis.sendCommand(hashTag, Protocol.Command.MSET, "key1" + hashTag, "value1",
+ "key2" + hashTag, "value2", "key3" + hashTag))
+ .hasMessageContaining("ERR wrong number of arguments");
}
@Test
@@ -83,7 +83,7 @@ public abstract class AbstractMSetIntegrationTest implements RedisIntegrationTes
String[] keys = new String[keyCount];
String[] vals = new String[keyCount];
for (int i = 0; i < keyCount; i++) {
- String key = randString();
+ String key = randString() + hashTag;
String val = randString();
keyvals[2 * i] = key;
keyvals[2 * i + 1] = val;
@@ -130,7 +130,7 @@ public abstract class AbstractMSetIntegrationTest implements RedisIntegrationTes
String[] keysAndVals2, String[] keys, String[] vals1,
String[] vals2) {
for (int i = 0; i < ITERATION_COUNT; i++) {
- String key = keyBaseName + i;
+ String key = keyBaseName + i + hashTag;
String value1 = val1BaseName + i;
String value2 = val2BaseName + i;
keysAndVals1[2 * i] = key;
@@ -149,7 +149,7 @@ public abstract class AbstractMSetIntegrationTest implements RedisIntegrationTes
CountDownLatch latch = new CountDownLatch(1);
ExecutorService pool = Executors.newFixedThreadPool(2);
Callable<String> callable1 = () -> jedis.mset(keysAndVals1);
- Callable<String> callable2 = () -> jedis2.mset(keysAndVals2);
+ Callable<String> callable2 = () -> jedis.mset(keysAndVals2);
Future<String> future1 = pool.submit(callable1);
Future<String> future2 = pool.submit(callable2);
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetNXIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetNXIntegrationTest.java
index 24c2fef..14a1c29 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetNXIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractMSetNXIntegrationTest.java
@@ -23,7 +23,8 @@ import java.util.Set;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -31,38 +32,39 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractMSetNXIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
+ private final String hashTag = "{111}";
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@Test
public void givenKeyNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.MSETNX))
+ assertThatThrownBy(() -> jedis.sendCommand("any", Protocol.Command.MSETNX))
.hasMessageContaining("ERR wrong number of arguments for 'msetnx' command");
}
@Test
public void givenValueNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.MSETNX, "key"))
+ assertThatThrownBy(() -> jedis.sendCommand("key", Protocol.Command.MSETNX, "key"))
.hasMessageContaining("ERR wrong number of arguments for 'msetnx' command");
}
@Test
public void givenEvenNumberOfArgumentsProvided_returnsWrongNumberOfArgumentsError() {
// Redis returns this message in this scenario: "ERR wrong number of arguments for MSET"
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.MSETNX, "key1", "value1", "key2",
- "value2", "key3"))
+ assertThatThrownBy(() -> jedis.sendCommand(hashTag, Protocol.Command.MSETNX, "key1" + hashTag,
+ "value1", "key2" + hashTag, "value2", "key3" + hashTag))
.hasMessageContaining("ERR wrong number of arguments");
}
@@ -70,7 +72,7 @@ public abstract class AbstractMSetNXIntegrationTest implements RedisIntegrationT
public void testMSetNX() {
Set<String> keysAndVals = new HashSet<String>();
for (int i = 0; i < 2 * 5; i++) {
- keysAndVals.add(randString());
+ keysAndVals.add(randString() + hashTag);
}
String[] keysAndValsArray = keysAndVals.toArray(new String[0]);
long response = jedis.msetnx(keysAndValsArray);
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractPSetEXIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractPSetEXIntegrationTest.java
index f5b6a73..ee107f3 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractPSetEXIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractPSetEXIntegrationTest.java
@@ -20,7 +20,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -28,18 +29,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractPSetEXIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetBitIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetBitIntegrationTest.java
index 40e6b75..f30d70f 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetBitIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetBitIntegrationTest.java
@@ -21,7 +21,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -29,18 +30,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractSetBitIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -52,7 +53,7 @@ public abstract class AbstractSetBitIntegrationTest implements RedisIntegrationT
@Test
public void givenMoreThanFourArgumentsProvided_returnsWrongNumberOfArgumentsError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.SETBIT, "key", "1", "value", "extraArg"))
+ () -> jedis.sendCommand("key", Protocol.Command.SETBIT, "key", "1", "value", "extraArg"))
.hasMessageContaining("ERR wrong number of arguments for 'setbit' command");
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java
index e59ff62..d45db82 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetEXIntegrationTest.java
@@ -21,7 +21,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -29,18 +30,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractSetEXIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@@ -59,7 +60,7 @@ public abstract class AbstractSetEXIntegrationTest implements RedisIntegrationTe
@Test
public void givenMoreThanFourArgumentsProvided_returnsWrongNumberOfArgumentsError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.SETEX, "key", "10", "value", "extraArg"))
+ () -> jedis.sendCommand("key", Protocol.Command.SETEX, "key", "10", "value", "extraArg"))
.hasMessageContaining("ERR wrong number of arguments for 'setex' command");
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetIntegrationTest.java
index a3cd171..ca5c410 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetIntegrationTest.java
@@ -30,7 +30,8 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.params.SetParams;
@@ -42,99 +43,100 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
- private Jedis jedis2;
+ private JedisCluster jedis;
+ private final String key = "key";
+ private final String value = "value";
private static final int ITERATION_COUNT = 4000;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
- jedis2.close();
}
@Test
public void givenKeyNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET))
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.SET))
.hasMessageContaining("ERR wrong number of arguments for 'set' command");
}
@Test
public void givenValueNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key"))
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.SET, key))
.hasMessageContaining("ERR wrong number of arguments for 'set' command");
}
@Test
public void givenEXKeyword_withoutParameter_returnsSyntaxError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "EX"))
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "EX"))
.hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void givenEXKeyword_whenParameterIsNotAnInteger_returnsNotIntegerError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "EX", "NaN"))
- .hasMessageContaining(ERROR_NOT_INTEGER);
+ assertThatThrownBy(
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "EX", "NaN"))
+ .hasMessageContaining(ERROR_NOT_INTEGER);
}
@Test
public void givenEXKeyword_whenParameterIsZero_returnsInvalidExpireTimeError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "PX", "0"))
- .hasMessageContaining(ERROR_INVALID_EXPIRE_TIME);
+ assertThatThrownBy(
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "PX", "0"))
+ .hasMessageContaining(ERROR_INVALID_EXPIRE_TIME);
}
@Test
public void givenPXKeyword_withoutParameter_returnsSyntaxError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "PX"))
+ assertThatThrownBy(() -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "PX"))
.hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void givenPXKeyword_whenParameterIsNotAnInteger_returnsNotIntegerError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "PX", "NaN"))
- .hasMessageContaining(ERROR_NOT_INTEGER);
+ assertThatThrownBy(
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "PX", "NaN"))
+ .hasMessageContaining(ERROR_NOT_INTEGER);
}
@Test
public void givenPXKeyword_whenParameterIsZero_returnsInvalidExpireTimeError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "PX", "0"))
- .hasMessageContaining(ERROR_INVALID_EXPIRE_TIME);
+ assertThatThrownBy(
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "PX", "0"))
+ .hasMessageContaining(ERROR_INVALID_EXPIRE_TIME);
}
@Test
public void givenPXAndEXInSameCommand_returnsSyntaxError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "PX", "3000", "EX", "3"))
- .hasMessageContaining(ERROR_SYNTAX);
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "PX", "3000", "EX",
+ "3"))
+ .hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void givenNXAndXXInSameCommand_returnsSyntaxError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "NX", "XX"))
- .hasMessageContaining(ERROR_SYNTAX);
+ assertThatThrownBy(
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "NX", "XX"))
+ .hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void givenInvalidKeyword_returnsSyntaxError() {
assertThatThrownBy(
- () -> jedis.sendCommand(Protocol.Command.SET, "key", "value", "invalidKeyword"))
+ () -> jedis.sendCommand(key, Protocol.Command.SET, key, value, "invalidKeyword"))
.hasMessageContaining(ERROR_SYNTAX);
}
@Test
public void testSET_shouldSetStringValueToKey_givenEmptyKey() {
-
- String key = "key";
- String value = "value";
-
String result = jedis.get(key);
assertThat(result).isNull();
@@ -145,116 +147,92 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_shouldSetStringValueToKey_givenKeyIsOfDataTypeSet() {
- String key = "key";
- String stringValue = "value";
-
jedis.sadd(key, "member1", "member2");
- jedis.set(key, stringValue);
+ jedis.set(key, value);
String result = jedis.get(key);
- assertThat(result).isEqualTo(stringValue);
+ assertThat(result).isEqualTo(value);
}
@Test
public void testSET_shouldSetStringValueToKey_givenKeyIsOfDataTypeHash() {
- String key = "key";
- String stringValue = "value";
-
jedis.hset(key, "field", "something else");
- String result = jedis.set(key, stringValue);
+ String result = jedis.set(key, value);
assertThat(result).isEqualTo("OK");
- assertThat(stringValue).isEqualTo(jedis.get(key));
+ assertThat(value).isEqualTo(jedis.get(key));
}
@Test
public void testSET_shouldSetNX_evenIfKeyContainsOtherDataType() {
- String key = "key";
- String stringValue = "value";
-
jedis.sadd(key, "member1", "member2");
SetParams setParams = new SetParams();
setParams.nx();
- String result = jedis.set(key, stringValue, setParams);
+ String result = jedis.set(key, value, setParams);
assertThat(result).isNull();
}
@Test
public void testSET_shouldSetXX_evenIfKeyContainsOtherDataType() {
- String key = "key";
- String stringValue = "value";
-
jedis.sadd(key, "member1", "member2");
SetParams setParams = new SetParams();
setParams.xx();
- jedis.set(key, stringValue, setParams);
+ jedis.set(key, value, setParams);
String result = jedis.get(key);
- assertThat(result).isEqualTo(stringValue);
+ assertThat(result).isEqualTo(value);
}
@Test
public void testSET_withNXAndExArguments() {
- String key = "key";
- String stringValue = "value";
-
SetParams setParams = new SetParams();
setParams.nx();
setParams.ex(20);
- jedis.set(key, stringValue, setParams);
+ jedis.set(key, value, setParams);
assertThat(jedis.ttl(key)).isGreaterThan(15);
- assertThat(jedis.get(key)).isEqualTo(stringValue);
+ assertThat(jedis.get(key)).isEqualTo(value);
}
@Test
public void testSET_withXXAndExArguments() {
- String key = "key";
- String stringValue = "value";
-
jedis.set(key, "differentValue");
SetParams setParams = new SetParams();
setParams.xx();
setParams.ex(20);
- jedis.set(key, stringValue, setParams);
+ jedis.set(key, value, setParams);
assertThat(jedis.ttl(key)).isGreaterThan(15);
- assertThat(jedis.get(key)).isEqualTo(stringValue);
+ assertThat(jedis.get(key)).isEqualTo(value);
}
@Test
public void testSET_withNXAndPxArguments() {
- String key = "key";
- String stringValue = "value";
-
SetParams setParams = new SetParams();
setParams.nx();
setParams.px(2000);
- jedis.set(key, stringValue, setParams);
+ jedis.set(key, value, setParams);
assertThat(jedis.pttl(key)).isGreaterThan(1500);
- assertThat(jedis.get(key)).isEqualTo(stringValue);
+ assertThat(jedis.get(key)).isEqualTo(value);
}
@Test
public void testSET_withXXAndPxArguments() {
- String key = "key";
- String stringValue = "value";
-
jedis.set(key, "differentValue");
SetParams setParams = new SetParams();
setParams.xx();
setParams.px(2000);
- jedis.set(key, stringValue, setParams);
+ jedis.set(key, value, setParams);
assertThat(jedis.pttl(key)).isGreaterThan(1500);
- assertThat(jedis.get(key)).isEqualTo(stringValue);
+ assertThat(jedis.get(key)).isEqualTo(value);
}
@Test
@@ -277,7 +255,7 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
counter.addAndGet(1);
}
},
- (i) -> jedis2.set(keys.get(i), values.get(i), setParams))
+ (i) -> jedis.set(keys.get(i), values.get(i), setParams))
.run();
assertThat(counter.get()).isEqualTo(ITERATION_COUNT);
@@ -285,8 +263,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_withEXArgument_shouldSetExpireTime() {
- String key = "key";
- String value = "value";
int secondsUntilExpiration = 20;
SetParams setParams = new SetParams();
@@ -301,8 +277,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_withNegativeEXTime_shouldReturnError() {
- String key = "key";
- String value = "value";
int millisecondsUntilExpiration = -1;
SetParams setParams = new SetParams();
@@ -315,8 +289,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_withPXArgument_shouldSetExpireTime() {
- String key = "key";
- String value = "value";
int millisecondsUntilExpiration = 20000;
SetParams setParams = new SetParams();
@@ -331,8 +303,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_withNegativePXTime_shouldReturnError() {
- String key = "key";
- String value = "value";
int millisecondsUntilExpiration = -1;
SetParams setParams = new SetParams();
@@ -345,8 +315,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_shouldClearPreviousTTL() {
- String key = "key";
- String value = "value";
int secondsUntilExpiration = 20;
SetParams setParams = new SetParams();
@@ -363,7 +331,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
public void testSET_withXXArgument_shouldClearPreviousTTL() {
- String key = "xx_key";
String value = "did exist";
int secondsUntilExpiration = 20;
SetParams setParamsXX = new SetParams();
@@ -404,8 +371,6 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
@Test
@Ignore("KEEPTTL is part of redis 6")
public void testSET_withKEEPTTL_shouldRetainPreviousTTL_onSuccess() {
- String key = "key";
- String value = "value";
int secondsToExpire = 30;
SetParams setParamsEx = new SetParams();
@@ -515,47 +480,47 @@ public abstract class AbstractSetIntegrationTest implements RedisIntegrationTest
public void testSET_withInvalidOptions() {
SoftAssertions soft = new SoftAssertions();
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET))
.as("invalid options #1")
.isInstanceOf(JedisDataException.class);
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "EX", "0"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "EX", "0"))
.as("invalid options #2")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "EX", "a"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "EX", "a"))
.as("invalid options #3")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("value is not an integer");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "PX", "1", "EX", "0"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "PX", "1", "EX", "0"))
.as("invalid options #4")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "PX", "1", "XX", "0"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "PX", "1", "XX", "0"))
.as("invalid options #5")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "PX", "XX", "0"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "PX", "XX", "0"))
.as("invalid options #6")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "1", "PX", "1"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "1", "PX", "1"))
.as("invalid options #7")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "foo", "bar", "NX", "XX"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, "bar", "NX", "XX"))
.as("invalid options #8")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
- soft.assertThatThrownBy(() -> jedis.sendCommand(SET, "key", "value", "blah"))
+ soft.assertThatThrownBy(() -> jedis.sendCommand(key, SET, key, value, "blah"))
.as("invalid options #9")
.isInstanceOf(JedisDataException.class)
.hasMessageContaining("syntax error");
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetNXIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetNXIntegrationTest.java
index 79fb759..62b675e 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetNXIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetNXIntegrationTest.java
@@ -22,7 +22,8 @@ import java.util.concurrent.atomic.AtomicLong;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.ConcurrentLoopingThreads;
@@ -31,37 +32,38 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractSetNXIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
@Test
public void givenKeyNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SETNX))
+ assertThatThrownBy(() -> jedis.sendCommand("any", Protocol.Command.SETNX))
.hasMessageContaining("ERR wrong number of arguments for 'setnx' command");
}
@Test
public void givenValueNotProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SETNX, "key"))
+ assertThatThrownBy(() -> jedis.sendCommand("key", Protocol.Command.SETNX, "key"))
.hasMessageContaining("ERR wrong number of arguments for 'setnx' command");
}
@Test
public void givenMoreThanThreeArgumentsProvided_returnsWrongNumberOfArgumentsError() {
- assertThatThrownBy(() -> jedis.sendCommand(Protocol.Command.SETNX, "key", "value", "extraArg"))
- .hasMessageContaining("ERR wrong number of arguments for 'setnx' command");
+ assertThatThrownBy(
+ () -> jedis.sendCommand("key", Protocol.Command.SETNX, "key", "value", "extraArg"))
+ .hasMessageContaining("ERR wrong number of arguments for 'setnx' command");
}
@Test
@@ -89,18 +91,15 @@ public abstract class AbstractSetNXIntegrationTest implements RedisIntegrationTe
@Test
public void testSetNX_whenCalledConcurrently() {
- Jedis jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
AtomicLong updateCount = new AtomicLong(0);
int iterations = 10000;
new ConcurrentLoopingThreads(iterations,
(i) -> updateCount.getAndAdd(jedis.setnx("key-" + i, "value-" + i)),
- (i) -> updateCount.getAndAdd(jedis2.setnx("key-" + i, "value-" + i)))
+ (i) -> updateCount.getAndAdd(jedis.setnx("key-" + i, "value-" + i)))
.runInLockstep();
assertThat(iterations).isEqualTo(updateCount.get());
-
- jedis2.close();
}
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetRangeIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetRangeIntegrationTest.java
index ecdd170..8a68eac 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetRangeIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractSetRangeIntegrationTest.java
@@ -21,7 +21,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import org.apache.geode.redis.RedisIntegrationTest;
@@ -29,18 +30,18 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractSetRangeIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis;
+ private JedisCluster jedis;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis.flushAll();
+ flushAll();
jedis.close();
}
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractStringIntegrationTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractStringIntegrationTest.java
index 5e2b567..16d94e4 100755
--- a/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractStringIntegrationTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AbstractStringIntegrationTest.java
@@ -23,7 +23,8 @@ import java.nio.charset.StandardCharsets;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
-import redis.clients.jedis.Jedis;
+import redis.clients.jedis.HostAndPort;
+import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisDataException;
@@ -33,21 +34,19 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
public abstract class AbstractStringIntegrationTest implements RedisIntegrationTest {
- private Jedis jedis1;
- private Jedis jedis2;
+ private JedisCluster jedis1;
private static final int REDIS_CLIENT_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
@Before
public void setUp() {
- jedis1 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
- jedis2 = new Jedis("localhost", getPort(), REDIS_CLIENT_TIMEOUT);
+ jedis1 = new JedisCluster(new HostAndPort("localhost", getPort()), REDIS_CLIENT_TIMEOUT);
}
@After
public void tearDown() {
- jedis1.flushAll();
+ flushAll();
jedis1.close();
}
diff --git a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryIntegrationTest.java
old mode 100755
new mode 100644
similarity index 81%
copy from geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
copy to geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryIntegrationTest.java
index 8c3a9ee..fcc52b5
--- a/geode-apis-compatible-with-redis/src/acceptanceTest/java/org/apache/geode/redis/internal/executor/string/AppendNativeRedisAcceptanceTest.java
+++ b/geode-apis-compatible-with-redis/src/integrationTest/java/org/apache/geode/redis/internal/executor/string/AppendMemoryIntegrationTest.java
@@ -14,15 +14,13 @@
*/
package org.apache.geode.redis.internal.executor.string;
-
import org.junit.ClassRule;
-import org.apache.geode.NativeRedisTestRule;
-
-public class AppendNativeRedisAcceptanceTest extends AbstractAppendIntegrationTest {
+import org.apache.geode.redis.GeodeRedisServerRule;
+public class AppendMemoryIntegrationTest extends AbstractAppendMemoryIntegrationTest {
@ClassRule
- public static NativeRedisTestRule server = new NativeRedisTestRule();
+ public static GeodeRedisServerRule server = new GeodeRedisServerRule();
@Override
public int getPort() {