@trieb.work/nextjs-turbo-redis-cache 1.18.0 → 1.18.1

package/test/vitest/integration/cache-components/scripts/redis-kill-reconnect.ts

@@ -1,243 +0,0 @@
-import { spawnSync } from 'child_process';
-
-type ContainerRuntime = 'podman' | 'docker';
-
-function sh(cmd: string, args: string[], opts: { timeoutMs?: number } = {}) {
-  const res = spawnSync(cmd, args, {
-    encoding: 'utf8',
-    timeout: opts.timeoutMs ?? 30_000,
-  });
-  if (res.error) throw res.error;
-  return {
-    code: res.status ?? -1,
-    stdout: res.stdout ?? '',
-    stderr: res.stderr ?? '',
-  };
-}
-
-function canRun(cmd: string) {
-  const res = spawnSync(cmd, ['--version'], {
-    encoding: 'utf8',
-    timeout: 3_000,
-  });
-  return !res.error && (res.status ?? 1) === 0;
-}
-
-function detectContainerRuntime(): ContainerRuntime {
-  if (process.env.CONTAINER_RUNTIME === 'podman') return 'podman';
-  if (process.env.CONTAINER_RUNTIME === 'docker') return 'docker';
-
-  if (canRun('podman')) return 'podman';
-  if (canRun('docker')) return 'docker';
-
-  throw new Error(
-    'Neither podman nor docker is available. Install one of them or set CONTAINER_RUNTIME.',
-  );
-}
-
-async function sleep(ms: number) {
-  await new Promise((r) => setTimeout(r, ms));
-}
-
-async function waitUntil(fn: () => Promise<boolean>, timeoutMs = 20_000) {
-  const start = Date.now();
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    if (await fn()) return;
-    if (Date.now() - start > timeoutMs) throw new Error('waitUntil timeout');
-    await sleep(200);
-  }
-}
-
-async function main() {
-  const runtime = detectContainerRuntime();
-  const name = `redis-e2e-${Math.random().toString(36).slice(2, 8)}`;
-
-  // Pick a free localhost port
-  const net = await import('net');
-  const port: number = await new Promise((resolve, reject) => {
-    const srv = net.createServer();
-    srv.on('error', reject);
-    srv.listen(0, '127.0.0.1', () => {
-      const addr = srv.address();
-      if (!addr || typeof addr === 'string')
-        return reject(new Error('bad addr'));
-      const p = addr.port;
-      srv.close(() => resolve(p));
-    });
-  });
-
-  // cleanup
-  sh(runtime, ['rm', '-f', name]);
-
-  // Start redis with keyspace notifications enabled (required by SyncedMap)
-  {
-    const r = sh(
-      runtime,
-      [
-        'run',
-        '-d',
-        '--rm',
-        '--name',
-        name,
-        '-p',
-        `${port}:6379`,
-        'docker.io/redis:7-alpine',
-        'redis-server',
-        '--notify-keyspace-events',
-        'Exe',
-      ],
-      { timeoutMs: 60_000 },
-    );
-    if (r.code !== 0) throw new Error(`podman run failed: ${r.stderr}`);
-  }
-
-  // Set env BEFORE importing in case any module-level code reads REDIS_URL.
-  // (With lazy init the singleton is no longer created at import time, but
-  //  setting env first is still good practice.)
-  process.env.REDIS_URL = `redis://127.0.0.1:${port}`;
-  process.env.VERCEL_URL = `e2e-${name}-`;
-
-  const { getRedisCacheComponentsHandler } = await import(
-    '../../../../../src/CacheComponentsHandler'
-  );
-  const { default: RedisStringsHandler } = await import(
-    '../../../../../src/RedisStringsHandler'
-  );
-
-  // Cache Components handler
-  const cacheComponentsHandler = getRedisCacheComponentsHandler({
-    redisUrl: `redis://127.0.0.1:${port}`,
-    socketOptions: {
-      connectTimeout: 2_000,
-      // allow redis client to reconnect; this scenario is about stability under restart
-      reconnectStrategy: (retries) => Math.min(50 + retries * 50, 500),
-    },
-  });
-
-  const cacheComponentsClient = (cacheComponentsHandler as any).client as {
-    ping: () => Promise<string>;
-    isReady: boolean;
-  };
-
-  await waitUntil(async () => cacheComponentsClient.isReady, 20_000);
-  if ((await cacheComponentsClient.ping()) !== 'PONG') {
-    throw new Error('expected PONG (cache components)');
-  }
-
-  // Regular handler
-  const regularHandler = new RedisStringsHandler({
-    redisUrl: `redis://127.0.0.1:${port}`,
-    socketOptions: {
-      connectTimeout: 2_000,
-      reconnectStrategy: (retries: number) => Math.min(50 + retries * 50, 500),
-    },
-    // Keep default offline queue behavior here; SyncedMap does initial sync during construction.
-    keyPrefix: `e2e-${name}-regular-`,
-  } as any);
-
-  const regularClient = (regularHandler as any).client as {
-    ping: () => Promise<string>;
-    isReady: boolean;
-  };
-
-  await waitUntil(async () => regularClient.isReady, 20_000);
-  if ((await regularClient.ping()) !== 'PONG') {
-    throw new Error('expected PONG (regular handler)');
-  }
-
-  // Seed a small entry so we know regular handler does real ops
-  await regularHandler.set(
-    'e2e-key',
-    {
-      kind: 'FETCH',
-      data: {
-        headers: {},
-        body: Buffer.from('hello').toString('base64'),
-        status: 200,
-        url: 'https://example.com/e2e',
-      },
-      revalidate: 10,
-    },
-    { isRoutePPREnabled: false, isFallback: false, tags: ['e2e'] },
-  );
-
-  const got = await regularHandler.get('e2e-key', {
-    kind: 'FETCH',
-    revalidate: 10,
-    fetchUrl: 'https://example.com/e2e',
-    fetchIdx: 0,
-    tags: ['e2e'],
-    softTags: [],
-    isFallback: false,
-  });
-  if (!got) throw new Error('expected cache hit (regular handler)');
-
-  // Kill redis
-  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
-
-  // Wait a bit, then start again
-  await sleep(500);
-
-  {
-    const r = sh(
-      runtime,
-      [
-        'run',
-        '-d',
-        '--rm',
-        '--name',
-        name,
-        '-p',
-        `${port}:6379`,
-        'docker.io/redis:7-alpine',
-        'redis-server',
-        '--notify-keyspace-events',
-        'Exe',
-      ],
-      { timeoutMs: 60_000 },
-    );
-    if (r.code !== 0) throw new Error(`${runtime} run2 failed: ${r.stderr}`);
-  }
-
-  // Should recover (both)
-  await waitUntil(async () => {
-    try {
-      return (await cacheComponentsClient.ping()) === 'PONG';
-    } catch {
-      return false;
-    }
-  }, 30_000);
-
-  await waitUntil(async () => {
-    try {
-      return (await regularClient.ping()) === 'PONG';
-    } catch {
-      return false;
-    }
-  }, 30_000);
-
-  // Shut down clients before cleaning up Redis, otherwise reconnect loops keep the process alive.
-  try {
-    await (cacheComponentsHandler as any).client?.quit?.();
-  } catch {}
-  try {
-    await (regularHandler as any).client?.quit?.();
-  } catch {}
-
-  // cleanup best effort
-  sh(runtime, ['rm', '-f', name]);
-
-  // If we reach here without crashing due to Socket already opened, we're good.
-  // (Vitest will check stdout for this line.)
-  process.stdout.write('OK\n');
-
-  // Ensure we exit even if background reconnect timers exist.
-  process.exit(0);
-}
-
-main().catch((err) => {
-  // Ensure we don't hide the key error string
-  console.error(err);
-  process.exit(1);
-});

package/test/vitest/integration/cache-components/scripts/redis-quit-vs-disconnect.ts

@@ -1,113 +0,0 @@
-/**
- * Demonstrates the difference between quit() and disconnect() on a
- * node-redis subscriber client while Redis is down.
- *
- * Scenario:
- * 1. Start Redis.
- * 2. Connect two subscriber clients and subscribe them.
- * 3. Kill Redis and wait for the reconnect loop to start.
- * 4. Subscriber A: call quit(). It should NOT resolve quickly while Redis is down.
- * 5. Subscriber B: call disconnect(). It must close the socket immediately.
- * 6. Restart Redis and verify that the disconnected subscriber stays dead.
- *
- * This shows why disconnect() is the correct teardown method during an outage.
- */
-
-import { createClient } from 'redis';
-import {
-  detectContainerRuntime,
-  getFreePort,
-  record,
-  sh,
-  sleep,
-  startRedis,
-} from './redis-test-helpers';
-
-async function createSubscriber(url: string) {
-  const client = createClient({
-    url,
-    socket: {
-      connectTimeout: 2_000,
-      reconnectStrategy: (retries: number) => Math.min(50 + retries * 50, 500),
-    },
-  });
-  client.on('error', () => {});
-  await client.connect();
-  await client.subscribe('test-channel', () => {});
-  return client;
-}
-
-async function main() {
-  const runtime = detectContainerRuntime();
-  const name = `redis-quit-disc-${Math.random().toString(36).slice(2, 8)}`;
-  const port = await getFreePort();
-
-  sh(runtime, ['rm', '-f', name]);
-  startRedis(runtime, name, port);
-
-  const url = `redis://127.0.0.1:${port}`;
-
-  const quitSubscriber = await createSubscriber(url);
-  const disconnectSubscriber = await createSubscriber(url);
-
-  record(
-    'subscribers-ready',
-    quitSubscriber.isReady && disconnectSubscriber.isReady,
-    `quitSub isReady=${quitSubscriber.isReady}, disconnectSub isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Kill Redis and let both clients enter their reconnect loops
-  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
-  await sleep(1_500);
-
-  // Test quit(): it should not resolve while Redis is unreachable.
-  const quitResult = await Promise.race([
-    quitSubscriber
-      .quit()
-      .then(() => 'resolved')
-      .catch((e) => `error:${e.message ?? e}`),
-    sleep(3_000).then(() => 'timeout'),
-  ]);
-
-  record(
-    'quit-does-not-immediately-close',
-    quitResult !== 'resolved',
-    `quit() result during outage: ${quitResult}`,
-  );
-
-  // Test disconnect(): it must close the client immediately, even during outage.
-  const disconnectStart = Date.now();
-  try {
-    await disconnectSubscriber.disconnect();
-  } catch (e: any) {
-    // If the client is already closed, that's still a successful teardown.
-  }
-  const disconnectDuration = Date.now() - disconnectStart;
-
-  record(
-    'disconnect-closes-immediately',
-    !disconnectSubscriber.isOpen && !disconnectSubscriber.isReady,
-    `disconnect() took ${disconnectDuration}ms, isOpen=${disconnectSubscriber.isOpen}, isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Restart Redis and make sure the disconnected client does not come back.
-  startRedis(runtime, name, port);
-  await sleep(1_500);
-
-  record(
-    'disconnected-client-stays-dead',
-    !disconnectSubscriber.isOpen && !disconnectSubscriber.isReady,
-    `after restart: isOpen=${disconnectSubscriber.isOpen}, isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Also clean up the quit subscriber so we don't leak the process.
-  try {
-    await quitSubscriber.disconnect();
-  } catch {}
-  sh(runtime, ['rm', '-f', name]);
-}
-
-main().catch((err) => {
-  process.stderr.write(String(err) + '\n');
-  process.exit(1);
-});