tests: add testWithProxiedCluster() function

Author: nkaradzhov

packages/client/lib/cluster/cluster-slots.spec.ts

@@ -1,7 +1,8 @@
 import { strict as assert } from 'node:assert';
 import { EventEmitter } from 'node:events';
-import { RedisClusterOptions, RedisClusterClientOptions } from './index';
+import { RedisClusterClientOptions } from './index';
 import RedisClusterSlots from './cluster-slots';
+import TestUtils, { GLOBAL } from '../test-utils'
 
 describe('RedisClusterSlots', () => {
   describe('initialization', () => {

packages/test-utils/lib/dockers.ts

@@ -9,6 +9,7 @@ import { promisify } from 'node:util';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import assert from 'node:assert';
 
 const execAsync = promisify(execFileCallback);
 
@@ -116,6 +117,69 @@ options: RedisServerDockerOptions, serverArguments: Array<string>): Promise<Redi
 }
 const RUNNING_SERVERS = new Map<Array<string>, ReturnType<typeof spawnRedisServerDocker>>();
 
+export interface ProxiedRedisServerDocker {
+  ports: number[],
+  dockerId: string
+}
+
+export interface ProxiedRedisServerConfig {
+  nOfProxies: number,
+  defaultInterceptors: ('cluster'|'hitless'|'logger')[]
+}
+
+const RUNNING_PROXIED_SERVERS = new Map<string, Promise<ProxiedRedisServerDocker>>();
+
+export async function spawnProxiedRedisServer(config: ProxiedRedisServerConfig): Promise<ProxiedRedisServerDocker> {
+  const key = JSON.stringify(config);
+  const runningServer = RUNNING_PROXIED_SERVERS.get(key);
+  if (runningServer) {
+    return runningServer;
+  }
+
+  const server = spawnProxiedRedisServerDocker(config);
+  RUNNING_PROXIED_SERVERS.set(key, server);
+  return server;
+}
+
+export async function spawnProxiedRedisServerDocker(
+  config: ProxiedRedisServerConfig,
+): Promise<ProxiedRedisServerDocker> {
+
+  assert(config.nOfProxies > 0, 'At least one proxy should be started');
+  const ports: number[] = [];
+  for (let i = 0; i < config.nOfProxies; i++) {
+    ports.push((await portIterator.next()).value);
+  }
+
+  const dockerArgs =[
+    "run",
+    "-d",
+    "--network", "host",
+    "-e", `LISTEN_PORT=${ports.join(',')}`,
+    "-e", "TIEOUT=0",
+    "-e", `DEFAULT_INTERCEPTORS=${config.defaultInterceptors.join(',')}`,
+    "-e", "ENABLE_LOGGING=true",
+    "cae-resp-proxy-standalone"
+  ]
+
+  console.log(`[Docker] Spawning Proxy container`, dockerArgs.join(' '));
+
+  const { stdout, stderr } = await execAsync("docker", dockerArgs);
+
+  if (!stdout) {
+    throw new Error(`docker run error - ${stderr}`);
+  }
+
+  while (await isPortAvailable(ports[0])) {
+    await setTimeout(50);
+  }
+
+  return {
+    ports,
+    dockerId: stdout.trim(),
+  };
+}
+
 export function spawnRedisServer(dockerConfig: RedisServerDockerOptions, serverArguments: Array<string>): Promise<RedisServerDocker> {
   const runningServer = RUNNING_SERVERS.get(serverArguments);
   if (runningServer) {
@@ -319,7 +383,7 @@ export async function spawnRedisSentinel(
     if (runningNodes) {
       return runningNodes;
     }
-    
+
     const passIndex = serverArguments.indexOf('--requirepass')+1;
     let password: string | undefined = undefined;
     if (passIndex != 0) {
@@ -329,7 +393,7 @@ export async function spawnRedisSentinel(
     const master = await spawnRedisServerDocker(dockerConfigs, serverArguments);
     const redisNodes: Array<RedisServerDocker> = [master];
     const replicaPromises: Array<Promise<RedisServerDocker>> = [];
-    
+
     const replicasCount = 2;
     for (let i = 0; i < replicasCount; i++) {
       replicaPromises.push((async () => {
@@ -344,37 +408,37 @@ export async function spawnRedisSentinel(
         await client.connect();
         await client.replicaOf("127.0.0.1", master.port);
         await client.close();
-        
+
         return replica;
       })());
     }
-    
+
     const replicas = await Promise.all(replicaPromises);
     redisNodes.push(...replicas);
     RUNNING_NODES.set(serverArguments, redisNodes);
 
     const sentinelPromises: Array<Promise<RedisServerDocker>> = [];
     const sentinelCount = 3;
-    
+
     const appPrefix = 'sentinel-config-dir';
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), appPrefix));
 
     for (let i = 0; i < sentinelCount; i++) {
       sentinelPromises.push(
         spawnSentinelNode(
-          dockerConfigs, 
-          serverArguments, 
+          dockerConfigs,
+          serverArguments,
           master.port,
           "mymaster",
           path.join(tmpDir, i.toString()),
           password,
         ),
       )
     }
-    
+
     const sentinelNodes = await Promise.all(sentinelPromises);
     RUNNING_SENTINELS.set(serverArguments, sentinelNodes);
-    
+
     if (tmpDir) {
       fs.rmSync(tmpDir, { recursive: true });
     }
@@ -396,14 +460,17 @@ after(() => {
     ...Array.from(RUNNING_SENTINELS.values()).map(dockersPromise =>
       Promise.all(dockersPromise.map(({ dockerId }) => dockerRemove(dockerId)))
     ),
+    ...Array.from(RUNNING_PROXIED_SERVERS.values()).map(async dockerPromise =>
+      dockerRemove((await dockerPromise).dockerId)
+    )
   ]);
 });
 
 
 export async function spawnSentinelNode(
   dockerConfigs: RedisServerDockerOptions,
   serverArguments: Array<string>,
-  masterPort: number, 
+  masterPort: number,
   sentinelName: string,
   tmpDir: string,
   password?: string,
@@ -429,12 +496,12 @@ sentinel failover-timeout ${sentinelName} 1000
 
   return await spawnRedisServerDocker(
     {
-      image: dockerConfigs.image, 
-      version: dockerConfigs.version, 
+      image: dockerConfigs.image,
+      version: dockerConfigs.version,
       mode: "sentinel",
-        mounts: [`${dir}/redis.conf:/redis/config/node-sentinel-1/redis.conf`], 
+        mounts: [`${dir}/redis.conf:/redis/config/node-sentinel-1/redis.conf`],
         port: port,
-    }, 
+    },
     serverArguments,
   );
-}
+}

packages/test-utils/lib/index.ts

@@ -19,7 +19,7 @@ import {
   RedisClusterType
 } from '@redis/client/index';
 import { RedisNode } from '@redis/client/lib/sentinel/types'
-import { spawnRedisServer, spawnRedisCluster, spawnRedisSentinel, RedisServerDockerOptions, RedisServerDocker, spawnSentinelNode, spawnRedisServerDocker } from './dockers';
+import { spawnRedisServer, spawnRedisCluster, spawnRedisSentinel, RedisServerDockerOptions, RedisServerDocker, spawnSentinelNode, spawnRedisServerDocker, spawnProxiedRedisServer } from './dockers';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 
@@ -28,6 +28,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { RedisProxy, getFreePortNumber } from './proxy/redis-proxy';
 
+
 interface TestUtilsConfig {
   /**
    * The name of the Docker image to use for spawning Redis test instances.
@@ -298,6 +299,54 @@ export default class TestUtils {
       }
     });
   }
+
+  testWithProxiedCluster<
+    M extends RedisModules = {},
+    F extends RedisFunctions = {},
+    S extends RedisScripts = {},
+    RESP extends RespVersions = 2,
+    TYPE_MAPPING extends TypeMapping = {}
+  >(
+    title: string,
+    fn: (proxiedClusterClient: RedisClusterType<M, F, S, RESP, TYPE_MAPPING>, proxyUrl: string) => unknown,
+    options: Omit<ClusterTestOptions<M, F, S, RESP, TYPE_MAPPING>, 'numberOfReplicas' | 'minimumDockerVersion' | 'serverArguments'>
+  ) {
+    let spawnPromise: ReturnType<typeof spawnProxiedRedisServer>;
+    before(function () {
+      this.timeout(30000);
+      spawnPromise = spawnProxiedRedisServer({ nOfProxies: options.numberOfMasters ?? 3, defaultInterceptors: ['cluster', 'hitless'] });
+    });
+
+    it(title, async function () {
+      if (!spawnPromise) return this.skip();
+      const { ports } = await spawnPromise;
+
+      const cluster = createCluster({
+        rootNodes: ports.map(port => ({
+          socket: {
+            port
+          }
+        })),
+        minimizeConnections: options.clusterConfiguration?.minimizeConnections ?? true,
+        ...options.clusterConfiguration
+      });
+
+      if(options.disableClusterSetup) {
+        return fn(cluster, 'hh');
+      }
+
+      await cluster.connect();
+
+      try {
+        await TestUtils.#clusterFlushAll(cluster);
+        await fn(cluster, 'hi');
+      } finally {
+        await TestUtils.#clusterFlushAll(cluster);
+        cluster.destroy();
+      }
+    });
+  }
+
   testWithProxiedClient(
     title: string,
     fn: (proxiedClient: RedisClientType<any, any, any, any, any>, proxy: RedisProxy) => unknown,