remove redundant tests

Author: nkaradzhov

packages/client/lib/commands/CLUSTER_INFO.spec.ts

@@ -18,27 +18,4 @@ describe('CLUSTER INFO', () => {
       'string'
     );
   }, GLOBAL.CLUSTERS.OPEN);
-
-  testUtils.testWithCluster('structural assertion - RESP2 bulk string format', async cluster => {
-    const client = await cluster.nodeClient(cluster.masters[0]);
-    const reply = await client.clusterInfo();
-
-    // Assert it's a string (RESP2 bulk string)
-    assert.equal(typeof reply, 'string');
-
-    // Assert the response follows the <field>:<value> CRLF-separated format
-    // Expected fields according to Redis docs
-    assert.ok(reply.includes('cluster_state:'), 'should contain cluster_state field');
-    assert.ok(reply.includes('cluster_slots_assigned:'), 'should contain cluster_slots_assigned field');
-    assert.ok(reply.includes('cluster_known_nodes:'), 'should contain cluster_known_nodes field');
-
-    // Assert CRLF line endings (this is the key structural element)
-    const lines = reply.split('\r\n').filter(line => line.length > 0);
-    assert.ok(lines.length > 0, 'should have multiple lines separated by CRLF');
-
-    // Each line should follow <field>:<value> format
-    for (const line of lines) {
-      assert.ok(line.includes(':'), `line "${line}" should contain colon separator`);
-    }
-  }, GLOBAL.CLUSTERS.OPEN);
 });

packages/client/lib/commands/CONFIG_GET.spec.ts

@@ -29,17 +29,6 @@ describe('CONFIG GET', () => {
     }
   }, GLOBAL.SERVERS.OPEN);
 
-  testUtils.testWithClient('client.configGet with specific parameter pins RESP2 structure', async client => {
-    const reply = await client.configGet('maxmemory');
-    // RESP2 returns object (transformed from array of tuples)
-    // This structural assertion would break if RESP3 returns a Map
-    assert.deepEqual(
-      Object.keys(reply).sort(),
-      ['maxmemory']
-    );
-    assert.equal(typeof reply.maxmemory, 'string');
-  }, GLOBAL.SERVERS.OPEN);
-
   testUtils.testWithClient('client.configSet.getSearchConfigSettingTest | Redis >= 8', async client => {
     assert.ok(
       await client.configGet('search-timeout'),

packages/client/lib/commands/HOTKEYS_GET.spec.ts

@@ -178,81 +178,4 @@ describe('HOTKEYS GET', () => {
     ...GLOBAL.SERVERS.OPEN,
     minimumDockerVersion: [8, 6]
   });
-
-  testUtils.testWithClient('client.hotkeysGet returns correct RESP2 structure', async client => {
-    // Clean up any existing state first
-    await client.hotkeysStop();
-    await client.hotkeysReset();
-
-    // Start tracking with both CPU and NET metrics
-    await client.hotkeysStart({
-      METRICS: { count: 2, CPU: true, NET: true }
-    });
-
-    // Perform some operations to generate hotkey data
-    await client.set('structureTestKey', 'value');
-    await client.get('structureTestKey');
-
-    // GET should return data with the expected RESP2 structure
-    const reply = await client.hotkeysGet();
-    assert.ok(reply !== null, 'Expected reply to not be null');
-
-    // Verify the structure is a plain object (not a Map or Array)
-    // This assertion pins down that RESP2 returns an array-of-pairs that gets transformed to an object
-    // If RESP3 sends a Map instead and transformReply isn't updated, this will break
-    assert.ok(typeof reply === 'object' && reply !== null && !Array.isArray(reply) && !(reply instanceof Map));
-
-    // Verify all required fields are present with correct types
-    // This structural assertion would break if the RESP2 array-of-pairs format changed to RESP3 map
-    const requiredFields = {
-      trackingActive: 'number',
-      sampleRatio: 'number',
-      selectedSlots: 'array',
-      allCommandsAllSlotsUs: 'number',
-      netBytesAllCommandsAllSlots: 'number',
-      collectionStartTimeUnixMs: 'number',
-      collectionDurationMs: 'number',
-      totalCpuTimeSysMs: 'number',
-      totalCpuTimeUserMs: 'number',
-      totalNetBytes: 'number'
-    };
-
-    for (const [field, expectedType] of Object.entries(requiredFields)) {
-      assert.ok(Object.prototype.hasOwnProperty.call(reply, field), `Field ${field} must be present`);
-      if (expectedType === 'array') {
-        assert.ok(Array.isArray((reply as any)[field]), `Field ${field} must be an array`);
-      } else {
-        assert.equal(typeof (reply as any)[field], expectedType, `Field ${field} must be ${expectedType}`);
-      }
-    }
-
-    // Verify metric arrays structure if present
-    if (reply.byCpuTimeUs) {
-      assert.ok(Array.isArray(reply.byCpuTimeUs), 'byCpuTimeUs must be an array');
-      reply.byCpuTimeUs.forEach(entry => {
-        // Each entry must be a plain object with 'key' and 'value' properties
-        // This pins down the RESP2 flat array [k1,v1,k2,v2] -> [{key:k1,value:v1},{key:k2,value:v2}] structure
-        assert.deepEqual(Object.keys(entry).sort(), ['key', 'value']);
-        assert.equal(typeof entry.key, 'string');
-        assert.equal(typeof entry.value, 'number');
-      });
-    }
-
-    if (reply.byNetBytes) {
-      assert.ok(Array.isArray(reply.byNetBytes), 'byNetBytes must be an array');
-      reply.byNetBytes.forEach(entry => {
-        assert.deepEqual(Object.keys(entry).sort(), ['key', 'value']);
-        assert.equal(typeof entry.key, 'string');
-        assert.equal(typeof entry.value, 'number');
-      });
-    }
-
-    // Clean up
-    await client.hotkeysStop();
-    await client.hotkeysReset();
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    minimumDockerVersion: [8, 6]
-  });
 });
-

packages/client/lib/commands/HOTKEYS_GET.ts

@@ -175,7 +175,7 @@ export default {
       if (reply === null) return null;
       return transformHotkeysGetReply(reply);
     },
-    3: undefined as unknown as () => ReplyUnion
+    3: undefined as unknown as () => HotkeysGetReply
   },
   unstableResp3: true
 } as const satisfies Command;

packages/client/lib/commands/LATENCY_DOCTOR.spec.ts

@@ -17,17 +17,4 @@ describe('LATENCY DOCTOR', () => {
       'string'
     );
   }, GLOBAL.SERVERS.OPEN);
-
-  testUtils.testWithClient('client.latencyDoctor returns plain bulk string (RESP2)', async client => {
-    const reply = await client.latencyDoctor();
-
-    // Must be a string (bulk string in RESP2, not verbatim string object)
-    assert.equal(typeof reply, 'string');
-
-    // Must be a plain primitive string, not an object
-    assert.ok(reply.constructor === String || typeof reply === 'string');
-
-    // Should not be a structured object (would indicate verbatim string transformation)
-    assert.ok(!(reply && typeof reply === 'object' && 'format' in reply));
-  }, GLOBAL.SERVERS.OPEN);
 });

packages/client/lib/commands/MEMORY_STATS.spec.ts

@@ -45,19 +45,4 @@ describe('MEMORY STATS', () => {
     }
   }, GLOBAL.SERVERS.OPEN);
 
-  testUtils.testWithClient('client.memoryStats - RESP2 returns plain object structure', async client => {
-    const memoryStats = await client.memoryStats();
-
-    // Structural assertions to ensure RESP2 returns a plain object (not Array, not Map)
-    assert.ok(typeof memoryStats === 'object', 'memoryStats should be an object');
-    assert.ok(memoryStats !== null, 'memoryStats should not be null');
-    assert.ok(!Array.isArray(memoryStats), 'memoryStats should not be an Array');
-    assert.ok(!(memoryStats instanceof Map), 'memoryStats should not be a Map');
-    assert.ok(memoryStats.constructor === Object, 'memoryStats should be a plain Object');
-
-    // Verify it has the expected keys as own properties
-    assert.ok(memoryStats.hasOwnProperty('peak.allocated'), 'should have peak.allocated');
-    assert.ok(memoryStats.hasOwnProperty('total.allocated'), 'should have total.allocated');
-    assert.ok(memoryStats.hasOwnProperty('dataset.percentage'), 'should have dataset.percentage');
-  }, GLOBAL.SERVERS.OPEN);
 });

packages/client/lib/commands/VEMB.spec.ts

@@ -25,36 +25,4 @@ describe('VEMB', () => {
     cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
   });
 
-  testUtils.testAll('vEmb returns exact array structure (RESP2)', async client => {
-    await client.vAdd('key', [1.0, 2.0, 3.0], 'element');
-
-    const result = await client.vEmb('key', 'element');
-    assert.ok(Array.isArray(result));
-    assert.equal(result.length, 3);
-    // Assert each element is a number (not string, not object)
-    result.forEach(val => {
-      assert.equal(typeof val, 'number');
-      assert.ok(!isNaN(val));
-    });
-    // Verify exact structure - any change from array to map/object would break this
-    assert.deepStrictEqual(Object.keys(result), ['0', '1', '2']);
-  }, {
-    client: { ...GLOBAL.SERVERS.OPEN, minimumDockerVersion: [8, 0] },
-    cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
-  });
-
-  testUtils.testWithClient('vEmb with RESP3', async client => {
-    await client.vAdd('resp3-key', [1.5, 2.5, 3.5, 4.5], 'resp3-element');
-
-    const result = await client.vEmb('resp3-key', 'resp3-element');
-    assert.ok(Array.isArray(result));
-    assert.equal(result.length, 4);
-    assert.equal(typeof result[0], 'number');
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    clientOptions: {
-      RESP: 3
-    },
-    minimumDockerVersion: [8, 0]
-  });
 });

packages/client/lib/commands/VINFO.spec.ts

@@ -18,71 +18,30 @@ describe('VINFO', () => {
 
     const result = await client.vInfo('key');
     assert.ok(typeof result === 'object' && result !== null);
-
-    assert.equal(result['vector-dim'], 3);
-    assert.equal(result['size'], 1);
-    assert.ok('quant-type' in result);
-    assert.ok('hnsw-m' in result);
-    assert.ok('projection-input-dim' in result);
-    assert.ok('max-level' in result);
-    assert.ok('attributes-count' in result);
-    assert.ok('vset-uid' in result);
-    assert.ok('hnsw-max-node-uid' in result);
-  }, {
-    client: { ...GLOBAL.SERVERS.OPEN, minimumDockerVersion: [8, 0] },
-    cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
-  });
-
-  testUtils.testWithClient('vInfo structural assertion (RESP2)', async client => {
-    await client.vAdd('key', [1.0, 2.0, 3.0], 'element');
-
-    const result = await client.vInfo('key');
-
-    // Structural assertion: ensure all expected keys exist and have correct types
-    assert.ok(typeof result === 'object' && result !== null);
-    assert.ok('quant-type' in result);
-    assert.equal(typeof result['quant-type'], 'string');
-    assert.ok('vector-dim' in result);
-    assert.equal(typeof result['vector-dim'], 'number');
-    assert.equal(result['vector-dim'], 3);
-    assert.ok('size' in result);
-    assert.equal(typeof result['size'], 'number');
-    assert.equal(result['size'], 1);
-    assert.ok('max-level' in result);
-    assert.equal(typeof result['max-level'], 'number');
-    assert.ok('vset-uid' in result);
-    assert.equal(typeof result['vset-uid'], 'number');
-    assert.ok('hnsw-max-node-uid' in result);
-    assert.equal(typeof result['hnsw-max-node-uid'], 'number');
-
-    // Verify it's a plain object (RESP2 transformation result), not an array or Map
-    assert.equal(Object.getPrototypeOf(result), null);
     assert.equal(Array.isArray(result), false);
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    minimumDockerVersion: [8, 0]
-  });
+    assert.equal(result instanceof Map, false);
+
+    const expectedKeys = [
+      'quant-type',
+      'hnsw-m',
+      'vector-dim',
+      'projection-input-dim',
+      'size',
+      'max-level',
+      'attributes-count',
+      'vset-uid',
+      'hnsw-max-node-uid'
+    ];
 
-  testUtils.testWithClient('vInfo with RESP3', async client => {
-    await client.vAdd('resp3-key', [1.0, 2.0, 3.0], 'resp3-element');
-
-    const result = await client.vInfo('resp3-key');
-    assert.ok(typeof result === 'object' && result !== null);
+    assert.deepEqual(
+      Object.keys(result).sort(),
+      expectedKeys.sort()
+    );
 
     assert.equal(result['vector-dim'], 3);
     assert.equal(result['size'], 1);
-    assert.ok('quant-type' in result);
-    assert.ok('hnsw-m' in result);
-    assert.ok('projection-input-dim' in result);
-    assert.ok('max-level' in result);
-    assert.ok('attributes-count' in result);
-    assert.ok('vset-uid' in result);
-    assert.ok('hnsw-max-node-uid' in result);
   }, {
-    ...GLOBAL.SERVERS.OPEN,
-    clientOptions: {
-      RESP: 3
-    },
-    minimumDockerVersion: [8, 0]
+    client: { ...GLOBAL.SERVERS.OPEN, minimumDockerVersion: [8, 0] },
+    cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
   });
 });

packages/client/lib/commands/VLINKS.spec.ts

@@ -24,37 +24,4 @@ describe('VLINKS', () => {
     client: { ...GLOBAL.SERVERS.OPEN, minimumDockerVersion: [8, 0] },
     cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
   });
-
-  testUtils.testWithClient('vLinks RESP2 response structure', async client => {
-    await client.vAdd('key', [1.0, 2.0, 3.0], 'element1');
-    await client.vAdd('key', [1.1, 2.1, 3.1], 'element2');
-    await client.vAdd('key', [1.2, 2.2, 3.2], 'element3');
-
-    const result = await client.vLinks('key', 'element1');
-    assert.ok(Array.isArray(result));
-    for (const layer of result) {
-      assert.ok(Array.isArray(layer));
-      for (const element of layer) {
-        assert.equal(typeof element, 'string');
-      }
-    }
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    minimumDockerVersion: [8, 0]
-  });
-
-  testUtils.testWithClient('vLinks with RESP3', async client => {
-    await client.vAdd('resp3-key', [1.0, 2.0, 3.0], 'element1');
-    await client.vAdd('resp3-key', [1.1, 2.1, 3.1], 'element2');
-
-    const result = await client.vLinks('resp3-key', 'element1');
-    assert.ok(Array.isArray(result));
-    assert.ok(result.length)
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    clientOptions: {
-      RESP: 3
-    },
-    minimumDockerVersion: [8, 0]
-  });
 });

packages/client/lib/commands/VSETATTR.spec.ts

@@ -35,37 +35,4 @@ describe('VSETATTR', () => {
     client: { ...GLOBAL.SERVERS.OPEN, minimumDockerVersion: [8, 0] },
     cluster: { ...GLOBAL.CLUSTERS.OPEN, minimumDockerVersion: [8, 0] }
   });
-
-  testUtils.testWithClient('vSetAttr - RESP2 returns boolean type', async client => {
-    await client.vAdd('key', [1.0, 2.0, 3.0], 'element');
-
-    const result = await client.vSetAttr('key', 'element', { name: 'test', value: 42 });
-
-    // RESP2 returns integer (0/1) but should be transformed to boolean
-    assert.strictEqual(typeof result, 'boolean');
-    assert.strictEqual(result, true);
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    minimumDockerVersion: [8, 0]
-  });
-
-  testUtils.testWithClient('vSetAttr with RESP3 - returns boolean', async client => {
-    await client.vAdd('resp3-key', [1.0, 2.0, 3.0], 'resp3-element');
-
-    const result = await client.vSetAttr('resp3-key', 'resp3-element', {
-      name: 'test-item',
-      category: 'electronics',
-      price: 99.99
-    });
-
-    // RESP3 returns boolean instead of number
-    assert.equal(typeof result, 'boolean');
-    assert.equal(result, true);
-  }, {
-    ...GLOBAL.SERVERS.OPEN,
-    clientOptions: {
-      RESP: 3
-    },
-    minimumDockerVersion: [8, 0]
-  });
 });