churn(test): use redislabs/client-libs-test for testing

- `FT.SUGGET` [`WITHSCORES`] [`WITHPAYLOAD`] are now returning empty array `[]` instead of `null` in `8.0-M04-pre`
- Update `FT.PROFILE` reply to include shards & coordinator profiles
- Update default redis server version to `8.0-M04-pre`
- `GEOPOS` command returns coordinates with 17 decimal places in Redis 8+ vs 14 decimal places in previous versions

Author: bobymicroby

.github/workflows/tests.yml

@@ -21,8 +21,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: ['18', '20', '22']
-        redis-version: ['6.2.6-v17', '7.2.0-v13', '7.4.0-v1']
+        node-version: [ '18', '20', '22' ]
+        redis-version: [ 'rs-7.2.0-v13', 'rs-7.4.0-v1', '8.0-M04-pre' ]
     steps:
       - uses: actions/checkout@v4
         with:

packages/bloom/lib/test-utils.ts

@@ -2,9 +2,9 @@ import TestUtils from '@redis/test-utils';
 import RedisBloomModules from '.';
 
 export default new TestUtils({
-  dockerImageName: 'redis/redis-stack',
+  dockerImageName: 'redislabs/client-libs-test',
   dockerImageVersionArgument: 'redisbloom-version',
-  defaultDockerVersion: '7.4.0-v1'
+  defaultDockerVersion: '8.0-M04-pre'
 });
 
 export const GLOBAL = {

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

@@ -32,21 +32,149 @@ describe('GEOPOS', () => {
 
   testUtils.testAll('geoPos with member', async client => {
     const coordinates = {
-      longitude: '-122.06429868936538696',
-      latitude: '37.37749628831998194'
+      longitude: '-122.06429868936539',
+      latitude: '37.37749628831998'
     };
 
     await client.geoAdd('key', {
       member: 'member',
       ...coordinates
     });
 
-    assert.deepEqual(
-      await client.geoPos('key', 'member'),
-      [coordinates]
+    const result = await client.geoPos('key', 'member');
+
+    /**
+     *  - Redis < 8: Returns coordinates with 14 decimal places (e.g., "-122.06429868936539")
+     *  - Redis 8+:  Returns coordinates with 17 decimal places (e.g., "-122.06429868936538696")
+     *
+     */
+    const PRECISION = 13; // Number of decimal places to compare
+
+    assert.ok(result.length === 1, 'Expected one result');
+
+    assert.ok(
+      compareWithPrecision(result[0].longitude, coordinates.longitude, PRECISION),
+      `Longitude mismatch: ${result[0].longitude} vs ${coordinates.longitude}`
+    );
+    assert.ok(
+      compareWithPrecision(result[0].latitude, coordinates.latitude, PRECISION),
+      `Latitude mismatch: ${result[0].latitude} vs ${coordinates.latitude}`
     );
   }, {
     client: GLOBAL.SERVERS.OPEN,
     cluster: GLOBAL.CLUSTERS.OPEN
   });
 });
+
+describe('compareWithPrecision', () => {
+  it('should match exact same numbers', () => {
+    assert.strictEqual(
+      compareWithPrecision('123.456789', '123.456789', 6),
+      true
+    );
+  });
+
+  it('should match when actual has more precision than needed', () => {
+    assert.strictEqual(
+      compareWithPrecision('123.456789123456', '123.456789', 6),
+      true
+    );
+  });
+
+  it('should match when expected has more precision than needed', () => {
+    assert.strictEqual(
+      compareWithPrecision('123.456789', '123.456789123456', 6),
+      true
+    );
+  });
+
+  it('should fail when decimals differ within precision', () => {
+    assert.strictEqual(
+      compareWithPrecision('123.456689', '123.456789', 6),
+      false
+    );
+  });
+
+  it('should handle negative numbers', () => {
+    assert.strictEqual(
+      compareWithPrecision('-122.06429868936538', '-122.06429868936539', 13),
+      true
+    );
+  });
+
+  it('should fail when integer parts differ', () => {
+    assert.strictEqual(
+      compareWithPrecision('124.456789', '123.456789', 6),
+      false
+    );
+  });
+
+  it('should handle zero decimal places', () => {
+    assert.strictEqual(
+      compareWithPrecision('123.456789', '123.456789', 0),
+      true
+    );
+  });
+
+  it('should handle numbers without decimal points', () => {
+    assert.strictEqual(
+      compareWithPrecision('123', '123', 6),
+      true
+    );
+  });
+
+  it('should handle one number without decimal point', () => {
+    assert.strictEqual(
+      compareWithPrecision('123', '123.000', 3),
+      false
+    );
+  });
+
+  it('should match Redis coordinates with different precision', () => {
+    assert.strictEqual(
+      compareWithPrecision(
+        '-122.06429868936538696',
+        '-122.06429868936539',
+        13
+      ),
+      true
+    );
+  });
+
+  it('should match Redis latitude with different precision', () => {
+    assert.strictEqual(
+      compareWithPrecision(
+        '37.37749628831998194',
+        '37.37749628831998',
+        14
+      ),
+      true
+    );
+  });
+});
+
+// Helper function to compare with fixed decimal places
+const compareWithPrecision = (actual, expected, decimals) => {
+  const actualDotIndex = actual.indexOf('.');
+  const expectedDotIndex = expected.indexOf('.');
+
+  // If either number doesn't have a decimal point
+  if (actualDotIndex === -1 || expectedDotIndex === -1) {
+    // If both don't have decimal points, compare directly
+    if (actualDotIndex === -1 && expectedDotIndex === -1) {
+      return actual === expected;
+    }
+    // If only one has a decimal point, add .000... to the other
+    const withoutDecimal = actualDotIndex === -1 ? actual : expected;
+    const withDecimal = actualDotIndex === -1 ? expected : actual;
+    return compareWithPrecision(withoutDecimal + '.0', withDecimal, decimals);
+  }
+
+  const integerPart = actual.slice(0, actualDotIndex);
+  const decimalPart = actual.slice(actualDotIndex + 1, actualDotIndex + 1 + decimals);
+
+  const expectedIntegerPart = expected.slice(0, expectedDotIndex);
+  const expectedDecimalPart = expected.slice(expectedDotIndex + 1, expectedDotIndex + 1 + decimals);
+
+  return integerPart === expectedIntegerPart && decimalPart === expectedDecimalPart;
+};

packages/client/lib/test-utils.ts

@@ -6,9 +6,9 @@ import { Command } from './RESP/types';
 import { BasicCommandParser } from './client/parser';
 
 const utils = new TestUtils({
-  dockerImageName: 'redis/redis-stack',
+  dockerImageName: 'redislabs/client-libs-test',
   dockerImageVersionArgument: 'redis-version',
-  defaultDockerVersion: '7.4.0-v1'
+  defaultDockerVersion: '8.0-M04-pre'
 });
 
 export default utils;

packages/entraid/lib/test-utils.ts

@@ -4,9 +4,9 @@ import TestUtils from '@redis/test-utils';
 import { EntraidCredentialsProvider } from './entraid-credentials-provider';
 
 export const testUtils = new TestUtils({
-  dockerImageName: 'redis/redis-stack',
+  dockerImageName: 'redislabs/client-libs-test',
   dockerImageVersionArgument: 'redis-version',
-  defaultDockerVersion: '7.4.0-v1'
+  defaultDockerVersion: '8.0-M04-pre'
 });
 
 const DEBUG_MODE_ARGS = testUtils.isVersionGreaterThan([7]) ?

packages/graph/lib/test-utils.ts

@@ -1,10 +1,11 @@
 import TestUtils from '@redis/test-utils';
 import RedisGraph from '.';
 
+
 export default new TestUtils({
-  dockerImageName: 'redis/redis-stack',
+  dockerImageName: 'redislabs/client-libs-test',
   dockerImageVersionArgument: 'redisgraph-version',
-  defaultDockerVersion: '7.4.0-v1'
+  defaultDockerVersion: '8.0-M04-pre'
 });
 
 export const GLOBAL = {

packages/json/lib/test-utils.ts

@@ -2,9 +2,9 @@ import TestUtils from '@redis/test-utils';
 import RedisJSON from '.';
 
 export default new TestUtils({
-  dockerImageName: 'redis/redis-stack',
+  dockerImageName: 'redislabs/client-libs-test',
   dockerImageVersionArgument: 'redisgraph-version',
-  defaultDockerVersion: '7.4.0-v1'
+  defaultDockerVersion: '8.0-M04-pre'
 });
 
 export const GLOBAL = {

packages/search/lib/commands/INFO.spec.ts

@@ -24,7 +24,14 @@ describe('INFO', () => {
                 index_name: 'index',
                 index_options: [],
                 index_definition: Object.create(null, {
-                    default_score: {
+
+                  indexes_all: {
+                    value: 'false',
+                    configurable: true,
+                    enumerable: true
+                  },
+
+                  default_score: {
                         value: '1',
                         configurable: true,
                         enumerable: true

packages/search/lib/commands/PROFILE_AGGREGATE.spec.ts

@@ -40,9 +40,9 @@ describe('PROFILE AGGREGATE', () => {
         ]);
 
         const res = await client.ft.profileAggregate('index', '*');
-        assert.deepEqual('None', res.profile.warning);
-        assert.ok(typeof res.profile.iteratorsProfile.counter === 'number');
-        assert.ok(typeof res.profile.parsingTime === 'string');
+        assert.deepEqual('None', res.shards[0].warning);
+        assert.ok(typeof res.shards[0].iteratorsProfile.counter === 'number');
+        assert.ok(typeof res.shards[0].parsingTime === 'string');
         assert.ok(res.results.total == 1);
     }, GLOBAL.SERVERS.OPEN);
 });

packages/search/lib/commands/PROFILE_AGGREGATE.ts

@@ -1,37 +1,38 @@
 import { CommandParser } from '@redis/client/dist/lib/client/parser';
-import { Command, ReplyUnion } from "@redis/client/dist/lib/RESP/types";
-import AGGREGATE, { AggregateRawReply, FtAggregateOptions, parseAggregateOptions } from "./AGGREGATE";
-import { ProfileOptions, ProfileRawReply, ProfileReply, transformProfile } from "./PROFILE_SEARCH";
+import { Command, ReplyUnion } from '@redis/client/dist/lib/RESP/types';
+import AGGREGATE, { AggregateRawReply, FtAggregateOptions, parseAggregateOptions } from './AGGREGATE';
+import { ProfileOptions, ProfileRawReply, ProfileReply, transformCoordinatorProfile, transformShardProfile } from './PROFILE_SEARCH';
 
 export default {
   NOT_KEYED_COMMAND: true,
-    IS_READ_ONLY: true,
-    parseCommand(
-      parser: CommandParser,
-      index: string,
-      query: string,
-      options?: ProfileOptions & FtAggregateOptions
-    ) {
-      parser.push('FT.PROFILE', index, 'AGGREGATE');
-    
-      if (options?.LIMITED) {
-        parser.push('LIMITED');
-      }
-    
-      parser.push('QUERY', query);
+  IS_READ_ONLY: true,
+  parseCommand(
+    parser: CommandParser,
+    index: string,
+    query: string,
+    options?: ProfileOptions & FtAggregateOptions
+  ) {
+    parser.push('FT.PROFILE', index, 'AGGREGATE');
 
-      parseAggregateOptions(parser, options)
-    },
-    transformReply: {
-      2: (reply: ProfileAggeregateRawReply): ProfileReply => {
-        return {
-          results: AGGREGATE.transformReply[2](reply[0]),
-          profile: transformProfile(reply[1])
-        }
-      },
-      3: undefined as unknown as () => ReplyUnion
+    if (options?.LIMITED) {
+      parser.push('LIMITED');
+    }
+
+    parser.push('QUERY', query);
+
+    parseAggregateOptions(parser, options)
+  },
+  transformReply: {
+    2: (reply: ProfileAggeregateRawReply): ProfileReply => {
+      return {
+        results: AGGREGATE.transformReply[2](reply[0]),
+        shards: transformShardProfile(reply[1]),
+        coordinator: transformCoordinatorProfile(reply[1])
+      }
     },
-    unstableResp3: true
-  } as const satisfies Command;
+    3: undefined as unknown as () => ReplyUnion
+  },
+  unstableResp3: true
+} as const satisfies Command;
 
-  type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;
+type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;