add ProxyController for easier proxy comms

Author: nkaradzhov

packages/test-utils/lib/dockers.ts

@@ -119,6 +119,7 @@ const RUNNING_SERVERS = new Map<Array<string>, ReturnType<typeof spawnRedisServe
 
 export interface ProxiedRedisServerDocker {
   ports: number[],
+  apiPort: number,
   dockerId: string
 }
 
@@ -150,12 +151,14 @@ export async function spawnProxiedRedisServerDocker(
   for (let i = 0; i < config.nOfProxies; i++) {
     ports.push((await portIterator.next()).value);
   }
+  const apiPort = (await portIterator.next()).value;
 
   const dockerArgs =[
     "run",
     "-d",
     "--network", "host",
     "-e", `LISTEN_PORT=${ports.join(',')}`,
+    "-e", `API_PORT=${apiPort}`,
     "-e", "TIEOUT=0",
     "-e", `DEFAULT_INTERCEPTORS=${config.defaultInterceptors.join(',')}`,
     "-e", "ENABLE_LOGGING=true",
@@ -176,6 +179,7 @@ export async function spawnProxiedRedisServerDocker(
 
   return {
     ports,
+    apiPort,
     dockerId: stdout.trim(),
   };
 }

packages/test-utils/lib/index.ts

@@ -27,6 +27,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { RedisProxy, getFreePortNumber } from './proxy/redis-proxy';
+import ProxyController from './proxy/proxy-controller';
 
 
 interface TestUtilsConfig {
@@ -308,7 +309,7 @@ export default class TestUtils {
     TYPE_MAPPING extends TypeMapping = {}
   >(
     title: string,
-    fn: (proxiedClusterClient: RedisClusterType<M, F, S, RESP, TYPE_MAPPING>, proxyUrl: string) => unknown,
+    fn: (proxiedClusterClient: RedisClusterType<M, F, S, RESP, TYPE_MAPPING>, proxyController: ProxyController) => unknown,
     options: Omit<ClusterTestOptions<M, F, S, RESP, TYPE_MAPPING>, 'numberOfReplicas' | 'minimumDockerVersion' | 'serverArguments'>
   ) {
     let spawnPromise: ReturnType<typeof spawnProxiedRedisServer>;
@@ -319,7 +320,7 @@ export default class TestUtils {
 
     it(title, async function () {
       if (!spawnPromise) return this.skip();
-      const { ports } = await spawnPromise;
+      const { ports, apiPort } = await spawnPromise;
 
       const cluster = createCluster({
         rootNodes: ports.map(port => ({
@@ -331,15 +332,17 @@ export default class TestUtils {
         ...options.clusterConfiguration
       });
 
+      const proxyController = new ProxyController(`http://localhost:${apiPort}`)
+
       if(options.disableClusterSetup) {
-        return fn(cluster, 'hh');
+        return fn(cluster, proxyController);
       }
 
       await cluster.connect();
 
       try {
         await TestUtils.#clusterFlushAll(cluster);
-        await fn(cluster, 'hi');
+        await fn(cluster, proxyController);
       } finally {
         await TestUtils.#clusterFlushAll(cluster);
         cluster.destroy();

packages/test-utils/lib/proxy/proxy-controller.ts

@@ -0,0 +1,103 @@
+export type ProxyStats = {
+  totalConnections: number;
+  activeConnections: number;
+  totalBytesReceived: number;
+  totalBytesSent: number;
+  totalCommandsReceived: number;
+  totalCommandsSent: number;
+};
+
+export type SendResult = {
+  success: boolean;
+  connectionId: string;
+  error?: string;
+};
+
+export type ProxyConfig = {
+  listenPort: number;
+  listenHost?: string;
+  targetHost: string;
+  targetPort: number;
+  timeout?: number;
+  enableLogging?: boolean;
+};
+
+export default class ProxyController {
+  constructor(private url: string) { }
+
+  private fetchJson(path: string, options?: RequestInit): Promise<unknown> {
+    return fetch(`${this.url}${path}`, options).then(res => res.json());
+  }
+
+  getStats(): Promise<Record<string, ProxyStats>> {
+    return this.fetchJson('/stats') as Promise<Record<string, ProxyStats>>;
+  }
+
+  getConnections(): Promise<Record<string, readonly string[]>> {
+    return this.fetchJson('/connections') as Promise<Record<string, readonly string[]>>;
+  }
+
+  getNodes(): Promise<{ ids: string[] }> {
+    return this.fetchJson('/nodes') as Promise<{ ids: string[] }>;
+  }
+
+  createNode(config: Partial<ProxyConfig>): Promise<{ success: boolean; cfg: ProxyConfig }> {
+    return this.fetchJson('/nodes', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(config)
+    }) as Promise<{ success: boolean; cfg: ProxyConfig }>;
+  }
+
+  deleteNode(nodeId: string): Promise<{ success: boolean }> {
+    return this.fetchJson(`/nodes/${nodeId}`, {
+      method: 'DELETE'
+    }) as Promise<{ success: boolean }>;
+  }
+
+  sendToClient(connectionId: string, data: string, encoding: 'base64' | 'raw' = 'base64'): Promise<SendResult> {
+    return this.fetchJson(`/send-to-client/${connectionId}?encoding=${encoding}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: data
+    }) as Promise<SendResult>;
+  }
+
+  sendToClients(connectionIds: string[], data: string, encoding: 'base64' | 'raw' = 'base64'): Promise<{ results: SendResult[] }> {
+    return this.fetchJson(`/send-to-clients?connectionIds=${connectionIds.join(',')}&encoding=${encoding}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: data
+    }) as Promise<{ results: SendResult[] }>;
+  }
+
+  sendToAllClients(data: string, encoding: 'base64' | 'raw' = 'base64'): Promise<{ results: SendResult[] }> {
+    return this.fetchJson(`/send-to-all-clients?encoding=${encoding}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: data
+    }) as Promise<{ results: SendResult[] }>;
+  }
+
+  closeConnection(connectionId: string): Promise<{ success: boolean; connectionId: string }> {
+    return this.fetchJson(`/connections/${connectionId}`, {
+      method: 'DELETE'
+    }) as Promise<{ success: boolean; connectionId: string }>;
+  }
+
+  createScenario(responses: string[], encoding: 'base64' | 'raw' = 'base64'): Promise<{ success: boolean; totalResponses: number }> {
+    return this.fetchJson('/scenarios', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ responses, encoding })
+    }) as Promise<{ success: boolean; totalResponses: number }>;
+  }
+
+  addInterceptor(name: string, match: string, response: string, encoding: 'base64' | 'raw' = 'base64'): Promise<{ success: boolean; name: string }> {
+    return this.fetchJson('/interceptors', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name, match, response, encoding })
+    }) as Promise<{ success: boolean; name: string }>;
+  }
+}