fix(sentinel): Migrated to the new testing framework, fixed issues that were discovered during transition

* [CAE-342] Fix a couple of bugs * Fixed issue with nodes masterauth persistency, changed docker container * [CAE-342] Fixed a couple of sentinel issues, enabled most tests * [CAE-342] Added comment * [CAE-342] Migrate majority of tests to testUtils * [CAE-342] Minor refactor * . * [CAE-342] Using cae containers for sentinel * [CAE-342] Improved resiliency of the legacy tests, added TSdoc comment * [CAE-342] Some extra logging, removed unneeded changes * [CAE-342] Moved docker env as optional part of redisserverdockerconfig * [CAE-342] Move password to serverArguments * [CAE-342] Moved ts-node to devDependencies * [CAE-342] Reverted legacy testing framework improvements
2025-08-06 02:15:48 +03:00 · 2025-04-30 15:56:29 +03:00
parent 048df302e4
commit 10ff6debab
9 changed files with 1459 additions and 1253 deletions
--- a/packages/test-utils/lib/dockers.ts
+++ b/packages/test-utils/lib/dockers.ts
@@ -4,9 +4,11 @@ import { once } from 'node:events';
 import { createClient } from '@redis/client/index';
 import { setTimeout } from 'node:timers/promises';
 // import { ClusterSlotsReply } from '@redis/client/dist/lib/commands/CLUSTER_SLOTS';
-
 import { execFile as execFileCallback } from 'node:child_process';
 import { promisify } from 'node:util';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';

 const execAsync = promisify(execFileCallback);

@@ -38,37 +40,64 @@ const portIterator = (async function* (): AsyncIterableIterator<number> {
  throw new Error('All ports are in use');
 })();

-export interface RedisServerDockerConfig {
+interface RedisServerDockerConfig {
  image: string;
  version: string;
 }

+interface SentinelConfig {
+  mode: "sentinel";
+  mounts: Array<string>;
+  port: number;
+}
+
+interface ServerConfig {
+  mode: "server";
+}
+
+export type RedisServerDockerOptions = RedisServerDockerConfig & (SentinelConfig | ServerConfig)
+
 export interface RedisServerDocker {
  port: number;
  dockerId: string;
 }

-async function spawnRedisServerDocker({
-  image,
-  version
-}: RedisServerDockerConfig, serverArguments: Array<string>): Promise<RedisServerDocker> {
-  const port = (await portIterator.next()).value;
+async function spawnRedisServerDocker(
+options: RedisServerDockerOptions, serverArguments: Array<string>): Promise<RedisServerDocker> {
+  let port;
+  if (options.mode == "sentinel") {
+    port = options.port;
+  } else {
+    port = (await portIterator.next()).value;
+  }
+
  const portStr = port.toString();

  const dockerArgs = [
    'run',
-    '-e', `PORT=${portStr}`,
-    '-d',
-    '--network', 'host',
-    `${image}:${version}`,
-    '--port', portStr
+    '--init',
+    '-e', `PORT=${portStr}`
  ];

-  if (serverArguments.length > 0) {
-    dockerArgs.push(...serverArguments);
+  if (options.mode == "sentinel") {
+    options.mounts.forEach(mount => {
+      dockerArgs.push('-v', mount);
+    });
  }

-  console.log(`[Docker] Spawning Redis container - Image: ${image}:${version}, Port: ${port}`);
+  dockerArgs.push(
+    '-d',
+    '--network', 'host',
+    `${options.image}:${options.version}`
+  );
+
+  if (serverArguments.length > 0) {
+    for (let i = 0; i < serverArguments.length; i++) {
+      dockerArgs.push(serverArguments[i])
+    }
+  }
+
+  console.log(`[Docker] Spawning Redis container - Image: ${options.image}:${options.version}, Port: ${port}, Mode: ${options.mode}`);

  const { stdout, stderr } = await execAsync('docker', dockerArgs);

@@ -87,7 +116,7 @@ async function spawnRedisServerDocker({
 }
 const RUNNING_SERVERS = new Map<Array<string>, ReturnType<typeof spawnRedisServerDocker>>();

-export function spawnRedisServer(dockerConfig: RedisServerDockerConfig, serverArguments: Array<string>): Promise<RedisServerDocker> {
+export function spawnRedisServer(dockerConfig: RedisServerDockerOptions, serverArguments: Array<string>): Promise<RedisServerDocker> {
  const runningServer = RUNNING_SERVERS.get(serverArguments);
  if (runningServer) {
    return runningServer;
@@ -113,7 +142,7 @@ after(() => {
  );
 });

-export interface RedisClusterDockersConfig extends RedisServerDockerConfig {
+export type RedisClusterDockersConfig = RedisServerDockerOptions & {
  numberOfMasters?: number;
  numberOfReplicas?: number;
 }
@@ -178,7 +207,7 @@ async function spawnRedisClusterNodeDockers(
 }

 async function spawnRedisClusterNodeDocker(
-  dockersConfig: RedisClusterDockersConfig,
+  dockersConfig: RedisServerDockerOptions,
  serverArguments: Array<string>,
  clientConfig?: Partial<RedisClusterClientOptions>
 ) {
@@ -291,3 +320,107 @@ after(() => {
    })
  );
 });
+
+
+const RUNNING_NODES = new Map<Array<string>, Array<RedisServerDocker>>();
+const RUNNING_SENTINELS = new Map<Array<string>, Array<RedisServerDocker>>();
+
+export async function spawnRedisSentinel(
+  dockerConfigs: RedisServerDockerOptions,
+  serverArguments: Array<string>,
+): Promise<Array<RedisServerDocker>> {
+    const runningNodes = RUNNING_SENTINELS.get(serverArguments);
+    if (runningNodes) {
+      return runningNodes;
+    }
+    
+    const passIndex = serverArguments.indexOf('--requirepass')+1;
+    let password: string | undefined = undefined;
+    if (passIndex != 0) {
+      password = serverArguments[passIndex];
+    }
+
+    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 () => {
+        const replica = await spawnRedisServerDocker(dockerConfigs, serverArguments);
+        const client = createClient({
+          socket: {
+            port: replica.port
+          },
+          password: password
+        });
+
+        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((async () => {
+        const port = (await portIterator.next()).value;
+
+        let sentinelConfig = `port ${port}
+sentinel monitor mymaster 127.0.0.1 ${master.port} 2
+sentinel down-after-milliseconds mymaster 5000
+sentinel failover-timeout mymaster 6000
+`;
+        if (password !== undefined) {
+          sentinelConfig += `requirepass ${password}\n`;
+          sentinelConfig += `sentinel auth-pass mymaster ${password}\n`;
+        }
+
+        const dir = fs.mkdtempSync(path.join(tmpDir, i.toString()));
+        fs.writeFile(`${dir}/redis.conf`, sentinelConfig, err => {
+          if (err) {
+            console.error("failed to create temporary config file", err);
+          }
+        });
+
+        return await spawnRedisServerDocker(
+          {
+            image: dockerConfigs.image, 
+            version: dockerConfigs.version, 
+            mode: "sentinel",
+             mounts: [`${dir}/redis.conf:/redis/config/node-sentinel-1/redis.conf`], 
+             port: port,
+            }, serverArguments);
+      })());
+    }
+    
+    const sentinelNodes = await Promise.all(sentinelPromises);
+    RUNNING_SENTINELS.set(serverArguments, sentinelNodes);
+    
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+
+    return sentinelNodes;
+}
+
+after(() => {
+  return Promise.all(
+    [...RUNNING_NODES.values(), ...RUNNING_SENTINELS.values()].map(async dockersPromise => {
+      return Promise.all(
+        dockersPromise.map(({ dockerId }) => dockerRemove(dockerId))
+      );
+    })
+  );
+});
--- a/packages/test-utils/lib/index.ts
+++ b/packages/test-utils/lib/index.ts
@@ -6,8 +6,11 @@ import {
  TypeMapping,
  // CommandPolicies,
  createClient,
+  createSentinel,
  RedisClientOptions,
  RedisClientType,
+  RedisSentinelOptions,
+  RedisSentinelType,
  RedisPoolOptions,
  RedisClientPoolType,
  createClientPool,
@@ -15,7 +18,8 @@ import {
  RedisClusterOptions,
  RedisClusterType
 } from '@redis/client/index';
-import { RedisServerDockerConfig, spawnRedisServer, spawnRedisCluster } from './dockers';
+import { RedisNode } from '@redis/client/lib/sentinel/types'
+import { spawnRedisServer, spawnRedisCluster, spawnRedisSentinel, RedisServerDockerOptions } from './dockers';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';

@@ -68,6 +72,24 @@ interface ClientTestOptions<
  disableClientSetup?: boolean;
 }

+interface SentinelTestOptions<
+  M extends RedisModules,
+  F extends RedisFunctions,
+  S extends RedisScripts,
+  RESP extends RespVersions,
+  TYPE_MAPPING extends TypeMapping
+> extends CommonTestOptions {
+  sentinelOptions?: Partial<RedisSentinelOptions<M, F, S, RESP, TYPE_MAPPING>>;
+  clientOptions?: Partial<RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>>;
+  scripts?: S;
+  functions?: F;
+  modules?: M;
+  disableClientSetup?: boolean;
+  replicaPoolSize?: number;
+  masterPoolSize?: number;
+  reserveClient?: boolean;
+}
+
 interface ClientPoolTestOptions<
  M extends RedisModules,
  F extends RedisFunctions,
@@ -148,13 +170,14 @@ export default class TestUtils {
  }

  readonly #VERSION_NUMBERS: Array<number>;
-  readonly #DOCKER_IMAGE: RedisServerDockerConfig;
+  readonly #DOCKER_IMAGE: RedisServerDockerOptions;

  constructor({ string, numbers }: Version, dockerImageName: string) {
    this.#VERSION_NUMBERS = numbers;
    this.#DOCKER_IMAGE = {
      image: dockerImageName,
-      version: string
+      version: string, 
+      mode: "server"
    };
  }

@@ -179,7 +202,6 @@ export default class TestUtils {
  }

  isVersionGreaterThanHook(minimumVersion: Array<number> | undefined): void {
-
    const isVersionGreaterThanHook = this.isVersionGreaterThan.bind(this);
    const versionNumber = this.#VERSION_NUMBERS.join('.');
    const minimumVersionString = minimumVersion?.join('.');
@@ -272,6 +294,81 @@ export default class TestUtils {
    });
  }

+  testWithClientSentinel<
+    M extends RedisModules = {},
+    F extends RedisFunctions = {},
+    S extends RedisScripts = {},
+    RESP extends RespVersions = 2,
+    TYPE_MAPPING extends TypeMapping = {}
+  >(
+    title: string,
+    fn: (sentinel: RedisSentinelType<M, F, S, RESP, TYPE_MAPPING>) => unknown,
+    options: SentinelTestOptions<M, F, S, RESP, TYPE_MAPPING>
+  ): void {
+    let dockerPromises: ReturnType<typeof spawnRedisSentinel>;
+
+    const passIndex = options.serverArguments.indexOf('--requirepass')+1;
+    let password: string | undefined = undefined;
+    if (passIndex != 0) {
+      password = options.serverArguments[passIndex];
+    }
+    
+    if (this.isVersionGreaterThan(options.minimumDockerVersion)) {
+      const dockerImage = this.#DOCKER_IMAGE;
+      before(function () {
+        this.timeout(30000);
+        dockerPromises = spawnRedisSentinel(dockerImage, options.serverArguments);
+        return dockerPromises;
+      });
+    }
+
+    it(title, async function () {
+      this.timeout(30000);
+      if (options.skipTest) return this.skip();
+      if (!dockerPromises) return this.skip();
+
+
+      const promises = await dockerPromises;
+      const rootNodes: Array<RedisNode> = promises.map(promise => ({
+        host: "127.0.0.1", 
+        port: promise.port
+      }));
+
+      const sentinel = createSentinel({
+        name: 'mymaster', 
+        sentinelRootNodes: rootNodes, 
+        nodeClientOptions: { 
+          password: password || undefined,
+        },
+        sentinelClientOptions: { 
+          password: password || undefined,
+        },
+        replicaPoolSize: options?.replicaPoolSize || 0,
+        scripts: options?.scripts || {},
+        modules: options?.modules || {},
+        functions: options?.functions || {},
+        masterPoolSize: options?.masterPoolSize || undefined,
+        reserveClient: options?.reserveClient || false,
+      }) as RedisSentinelType<M, F, S, RESP, TYPE_MAPPING>;
+
+      if (options.disableClientSetup) {
+        return fn(sentinel);
+      }
+
+      await sentinel.connect();
+
+      try {
+        await sentinel.flushAll();
+        await fn(sentinel);
+      } finally {
+        if (sentinel.isOpen) {
+          await sentinel.flushAll();
+          sentinel.destroy();
+        }
+      }
+    });
+  }
+
  testWithClientIfVersionWithinRange<
    M extends RedisModules = {},
    F extends RedisFunctions = {},
@@ -290,9 +387,28 @@ export default class TestUtils {
    } else {
      console.warn(`Skipping test ${title} because server version ${this.#VERSION_NUMBERS.join('.')} is not within range ${range[0].join(".")} - ${range[1] !== 'LATEST' ? range[1].join(".") : 'LATEST'}`)
    }
-
  }

+  testWithClienSentineltIfVersionWithinRange<
+  M extends RedisModules = {},
+  F extends RedisFunctions = {},
+  S extends RedisScripts = {},
+  RESP extends RespVersions = 2,
+  TYPE_MAPPING extends TypeMapping = {}
+>(
+  range: ([minVersion: Array<number>, maxVersion: Array<number>] | [minVersion: Array<number>, 'LATEST']),
+  title: string,
+  fn: (sentinel: RedisSentinelType<M, F, S, RESP, TYPE_MAPPING>) => unknown,
+  options: SentinelTestOptions<M, F, S, RESP, TYPE_MAPPING>
+): void {
+
+  if (this.isVersionInRange(range[0], range[1] === 'LATEST' ? [Infinity, Infinity, Infinity] : range[1])) {
+    return this.testWithClientSentinel(`${title}  [${range[0].join('.')}] - [${(range[1] === 'LATEST') ? range[1] : range[1].join(".")}] `, fn, options)
+  } else {
+    console.warn(`Skipping test ${title} because server version ${this.#VERSION_NUMBERS.join('.')} is not within range ${range[0].join(".")} - ${range[1] !== 'LATEST' ? range[1].join(".") : 'LATEST'}`)
+  }
+}
+
  testWithClientPool<
    M extends RedisModules = {},
    F extends RedisFunctions = {},