fix(jedis-compatibility): remove duplicate test methods and fix syntax errors

Signed-off-by: prashanna-frsh <prashanna.rajendran@freshworks.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: prashanna-frsh

java/integTest/src/test/java/compatibility/jedis/JedisTest.java

@@ -3967,173 +3967,5 @@ private static String getFullExceptionMessage(Throwable t) {
             t = t.getCause();
         }
         return sb.toString();
-    // ========== STREAM COMMANDS ==========
-
-    @Test
-    void stream_xadd_xlen_xdel() {
-        String key = "stream:" + UUID.randomUUID();
-        Map<String, String> hash = new HashMap<>();
-        hash.put("f1", "v1");
-        hash.put("f2", "v2");
-
-        StreamEntryID id = jedis.xadd(key, hash);
-        assertNotNull(id, "XADD should return entry ID");
-        assertTrue(id.getTime() > 0 || id.getSequence() >= 0, "XADD should return valid ID");
-
-        long len = jedis.xlen(key);
-        assertEquals(1, len, "XLEN should be 1 after one XADD");
-
-        long del = jedis.xdel(key, id.toString());
-        assertEquals(1, del, "XDEL should return 1");
-        assertEquals(0, jedis.xlen(key), "XLEN should be 0 after XDEL");
-    }
-
-    @Test
-    void stream_xrange_xrevrange() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("a", "1"));
-        jedis.xadd(key, Map.of("b", "2"));
-        jedis.xadd(key, Map.of("c", "3"));
-
-        List<StreamEntry> range = jedis.xrange(key, "-", "+");
-        assertNotNull(range);
-        assertTrue(range.size() >= 3, "XRANGE should return at least 3 entries");
-
-        List<StreamEntry> rev = jedis.xrevrange(key, "+", "-");
-        assertNotNull(rev);
-        assertTrue(rev.size() >= 3, "XREVRANGE should return at least 3 entries");
-
-        List<StreamEntry> limited = jedis.xrange(key, "-", "+", 2L);
-        assertNotNull(limited);
-        assertEquals(2, limited.size(), "XRANGE with COUNT 2 should return 2 entries");
-    }
-
-    @Test
-    void stream_xread() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("x", "1"));
-
-        Map<String, String> keysAndIds = new HashMap<>();
-        keysAndIds.put(key, "0-0");
-
-        Map<String, List<StreamEntry>> result = jedis.xread(keysAndIds);
-        assertNotNull(result);
-        assertTrue(result.containsKey(key));
-        assertFalse(result.get(key).isEmpty(), "XREAD should return entries from start");
-    }
-
-    @Test
-    void stream_xtrim() {
-        String key = "stream:" + UUID.randomUUID();
-        for (int i = 0; i < 10; i++) {
-            jedis.xadd(key, Map.of("i", String.valueOf(i)));
-        }
-        long lenBefore = jedis.xlen(key);
-        assertTrue(lenBefore >= 10, "Stream should have at least 10 entries");
-
-        long trimmed = jedis.xtrim(key, 5L);
-        assertTrue(trimmed >= 0, "XTRIM should return non-negative count");
-        long lenAfter = jedis.xlen(key);
-        assertTrue(lenAfter <= 5, "Stream length after XTRIM MAXLEN 5 should be <= 5");
-    }
-
-    @Test
-    void stream_xgroup_create_destroy() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("init", "1"));
-
-        String group = "g1";
-        String createResult = jedis.xgroupCreate(key, group, "0", true);
-        assertNotNull(createResult, "XGROUP CREATE should succeed");
-
-        boolean destroyed = jedis.xgroupDestroy(key, group);
-        assertTrue(destroyed, "XGROUP DESTROY should return true");
-    }
-
-    @Test
-    void stream_xgroup_setid_createconsumer_delconsumer() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("a", "1"));
-        String group = "g2";
-        jedis.xgroupCreate(key, group, "0", true);
-
-        String setidResult = jedis.xgroupSetId(key, group, "0");
-        assertNotNull(setidResult);
-
-        boolean created = jedis.xgroupCreateConsumer(key, group, "c1");
-        assertTrue(created, "XGROUP CREATECONSUMER should succeed");
-
-        long del = jedis.xgroupDelConsumer(key, group, "c1");
-        assertTrue(del >= 0, "XGROUP DELCONSUMER should return non-negative");
-    }
-
-    @Test
-    void stream_xreadgroup_xack() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("m1", "v1"));
-        jedis.xadd(key, Map.of("m2", "v2"));
-        String group = "g3";
-        jedis.xgroupCreate(key, group, "0", true);
-
-        Map<String, String> keysAndIds = new HashMap<>();
-        keysAndIds.put(key, ">");
-
-        Map<String, List<StreamEntry>> read = jedis.xreadgroup(group, "consumer1", keysAndIds);
-        assertNotNull(read);
-        assertTrue(read.containsKey(key));
-        List<StreamEntry> entries = read.get(key);
-        assertNotNull(entries);
-        assertFalse(entries.isEmpty(), "XREADGROUP should return entries");
-
-        String[] ids = entries.stream().map(e -> e.getID().toString()).toArray(String[]::new);
-        long ack = jedis.xack(key, group, ids);
-        assertEquals(entries.size(), ack, "XACK should acknowledge all read entries");
-    }
-
-    @Test
-    void stream_xpending() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("p", "1"));
-        String group = "g4";
-        jedis.xgroupCreate(key, group, "0", true);
-
-        StreamPendingSummary summary = jedis.xpending(key, group);
-        assertNotNull(summary);
-        assertTrue(summary.getTotal() >= 0, "XPENDING summary total should be non-negative");
-
-        List<StreamPendingEntry> pending = jedis.xpending(key, group, "-", "+", 10L);
-        assertNotNull(pending);
-    }
-
-    @Test
-    void stream_xinfo_stream_and_groups() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("i", "1"));
-        jedis.xgroupCreate(key, "ginfo", "0", true);
-
-        Map<String, Object> raw = jedis.xinfoStream(key);
-        assertNotNull(raw);
-        assertTrue(raw.containsKey("length") || raw.containsKey("last-generated-id"));
-
-        StreamInfo info = jedis.xinfoStreamAsInfo(key);
-        assertNotNull(info);
-        assertTrue(info.getLength() >= 1, "Stream should have at least 1 entry");
-
-        List<StreamGroupInfo> groups = jedis.xinfoGroups(key);
-        assertNotNull(groups);
-        assertFalse(groups.isEmpty(), "XINFO GROUPS should return at least one group");
-    }
-
-    @Test
-    void stream_xinfo_consumers() {
-        String key = "stream:" + UUID.randomUUID();
-        jedis.xadd(key, Map.of("c", "1"));
-        String group = "gcons";
-        jedis.xgroupCreate(key, group, "0", true);
-        jedis.xgroupCreateConsumer(key, group, "consumer1");
-
-        List<StreamConsumerInfo> consumers = jedis.xinfoConsumers(key, group);
-        assertNotNull(consumers);
-        assertFalse(consumers.isEmpty(), "XINFO CONSUMERS should return at least one consumer");
     }
 }

java/jedis-compatibility/src/test/java/redis/clients/jedis/JedisMethodsTest.java

@@ -5,9 +5,6 @@
 
 import java.lang.reflect.Method;
 import java.util.List;
-import java.util.Set;
-import org.junit.jupiter.api.Test;
-import redis.clients.jedis.resps.AccessControlUser;
 import java.util.Map;
 import java.util.Set;
 import org.junit.jupiter.api.Test;
@@ -189,6 +186,9 @@ public void testAclMethodSignatures() throws NoSuchMethodException {
         Method aclDryRun =
                 jedisClass.getMethod("aclDryRun", String.class, String.class, String[].class);
         assertEquals(String.class, aclDryRun.getReturnType());
+    }
+
+    @Test
     public void testStreamMethodSignaturesExist() throws NoSuchMethodException {
         Class<Jedis> jedisClass = Jedis.class;
 
@@ -306,63 +306,6 @@ public void testStreamMethodReturnTypes() throws NoSuchMethodException {
         assertEquals(List.class, xinfoConsumers.getReturnType());
     }
 
-    @Test
-    public void testAclMethodSignatures() throws NoSuchMethodException {
-        Class<Jedis> jedisClass = Jedis.class;
-
-        Method aclList = jedisClass.getMethod("aclList");
-        assertEquals(List.class, aclList.getReturnType());
-
-        Method aclGetUser = jedisClass.getMethod("aclGetUser", String.class);
-        assertEquals(AccessControlUser.class, aclGetUser.getReturnType());
-
-        Method aclSetUserNoRules = jedisClass.getMethod("aclSetUser", String.class);
-        assertEquals(String.class, aclSetUserNoRules.getReturnType());
-
-        Method aclSetUserWithRules = jedisClass.getMethod("aclSetUser", String.class, String[].class);
-        assertEquals(String.class, aclSetUserWithRules.getReturnType());
-
-        Method aclDelUser = jedisClass.getMethod("aclDelUser", String[].class);
-        assertEquals(long.class, aclDelUser.getReturnType());
-
-        Method aclCatNoArg = jedisClass.getMethod("aclCat");
-        assertEquals(List.class, aclCatNoArg.getReturnType());
-
-        Method aclCatCategory = jedisClass.getMethod("aclCat", String.class);
-        assertEquals(List.class, aclCatCategory.getReturnType());
-
-        Method aclGenPassNoArg = jedisClass.getMethod("aclGenPass");
-        assertEquals(String.class, aclGenPassNoArg.getReturnType());
-
-        Method aclGenPassBits = jedisClass.getMethod("aclGenPass", int.class);
-        assertEquals(String.class, aclGenPassBits.getReturnType());
-
-        Method aclLogNoArg = jedisClass.getMethod("aclLog");
-        assertEquals(List.class, aclLogNoArg.getReturnType());
-
-        Method aclLogCount = jedisClass.getMethod("aclLog", int.class);
-        assertEquals(List.class, aclLogCount.getReturnType());
-
-        Method aclLogReset = jedisClass.getMethod("aclLogReset");
-        assertEquals(String.class, aclLogReset.getReturnType());
-
-        Method aclWhoAmI = jedisClass.getMethod("aclWhoAmI");
-        assertEquals(String.class, aclWhoAmI.getReturnType());
-
-        Method aclUsers = jedisClass.getMethod("aclUsers");
-        assertEquals(List.class, aclUsers.getReturnType());
-
-        Method aclSave = jedisClass.getMethod("aclSave");
-        assertEquals(String.class, aclSave.getReturnType());
-
-        Method aclLoad = jedisClass.getMethod("aclLoad");
-        assertEquals(String.class, aclLoad.getReturnType());
-
-        Method aclDryRun =
-                jedisClass.getMethod("aclDryRun", String.class, String.class, String[].class);
-        assertEquals(String.class, aclDryRun.getReturnType());
-    }
-
     @Test
     public void testStreamBinaryMethodSignaturesExist() throws NoSuchMethodException {
         Class<Jedis> jedisClass = Jedis.class;