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

package/test/vitest/integration/pages-router.integration.test.ts

@@ -1,430 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
-import fetch from 'node-fetch';
-import { createClient, RedisClientType } from 'redis';
-import { join } from 'path';
-import { readFileSync } from 'fs';
-import { CacheEntry } from '../../../src/RedisStringsHandler';
-
-// Select which Pages Router test app to use. Can be overridden via NEXT_PAGES_TEST_APP env var
-const NEXT_PAGES_TEST_APP =
-  process.env.NEXT_PAGES_TEST_APP || 'next-pages-16-2-6';
-const NEXT_APP_DIR = join(
-  __dirname,
-  '..',
-  '..',
-  'nextjs-test-projects',
-  NEXT_PAGES_TEST_APP,
-);
-console.log('NEXT_APP_DIR', NEXT_APP_DIR);
-
-// Two instances of the same build sharing one Redis. This mirrors a
-// load-balanced multi-instance deployment and is used to prove that
-// on-demand revalidation (res.revalidate) on one instance is picked up
-// by the other instance.
-const INSTANCE_A_PORT = 3061;
-const INSTANCE_B_PORT = 3062;
-const INSTANCE_A_URL = `http://localhost:${INSTANCE_A_PORT}`;
-const INSTANCE_B_URL = `http://localhost:${INSTANCE_B_PORT}`;
-
-const REDIS_BACKGROUND_SYNC_DELAY = 250; //ms delay to prevent flaky tests in slow CI environments
-
-// Default inMemoryCachingTime of the handler is 10s. After a get(), an
-// instance may serve the entry from its in-memory deduplication cache for up
-// to this long, so cross-instance freshness tests wait it out first.
-const IN_MEMORY_CACHE_EXPIRY_DELAY = 11_000;
-
-// revalidate value of /isr/[slug] in the test app
-const ISR_REVALIDATE_SECONDS = 300;
-// default stale age of the cache handler (14 days)
-const DEFAULT_STALE_AGE = 60 * 60 * 24 * 14;
-
-let instanceA: ChildProcessWithoutNullStreams;
-let instanceB: ChildProcessWithoutNullStreams;
-let redisClient: RedisClientType;
-let buildId: string;
-
-async function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function expectIsrRedisTtl(ttl: number) {
-  // Next.js 16.3+ passes cacheControl.expire (~1 year) for ISR pages.
-  // Redis TTL is keyed on expire, not 2 × revalidate.
-  if (NEXT_PAGES_TEST_APP.includes('16-3')) {
-    expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS);
-    return;
-  }
-  // VERCEL_ENV=production -> expire age is 2 * revalidate
-  expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS - 30);
-  expect(ttl).toBeLessThanOrEqual(2 * ISR_REVALIDATE_SECONDS);
-}
-
-async function runCommand(cmd: string, args: string[], cwd: string) {
-  return new Promise((resolve, reject) => {
-    let stderr = '';
-    let stdout = '';
-    const proc = spawn(cmd, args, { cwd, stdio: 'pipe' });
-
-    proc.stdout.on('data', (data) => {
-      if (process.env.DEBUG_INTEGRATION) {
-        console.log(data.toString());
-      }
-      stdout += data.toString();
-    });
-
-    proc.stderr.on('data', (data) => {
-      if (process.env.DEBUG_INTEGRATION) {
-        console.error(data.toString());
-      }
-      stderr += data.toString();
-    });
-
-    proc.on('exit', (code) => {
-      if (code === 0) resolve(undefined);
-      else {
-        reject(
-          new Error(
-            `${cmd} ${args.join(' ')} failed with code ${code}\n` +
-              `stdout: ${stdout}\n` +
-              `stderr: ${stderr}`,
-          ),
-        );
-      }
-    });
-  });
-}
-
-function startInstance(port: number): ChildProcessWithoutNullStreams {
-  const proc = spawn('npx', ['next', 'start', '-p', String(port)], {
-    cwd: NEXT_APP_DIR,
-    env: {
-      ...process.env,
-    },
-    stdio: 'pipe',
-  });
-  if (process.env.DEBUG_INTEGRATION) {
-    proc.stdout.on('data', (data) => {
-      console.log(`stdout(:${port}): ${data}`);
-    });
-  }
-  proc.stderr.on('data', (data) => {
-    console.error(`stderr(:${port}): ${data}`);
-  });
-  return proc;
-}
-
-async function waitForServer(url: string, timeout = 20000) {
-  const start = Date.now();
-  while (Date.now() - start < timeout) {
-    try {
-      const res = await fetch(url);
-      if (res.ok) return;
-    } catch {}
-    await new Promise((r) => setTimeout(r, 300));
-  }
-  throw new Error(`Next.js server at ${url} did not start in time`);
-}
-
-function extractTimestamp(html: string): number {
-  const match = html.match(/Timestamp: (?:<!-- -->)?(\d+)/)?.[1];
-  expect(match).toBeDefined();
-  return Number(match);
-}
-
-function extractCounter(html: string): number {
-  const match = html.match(/Counter: (?:<!-- -->)?(\d+)/)?.[1];
-  expect(match).toBeDefined();
-  return Number(match);
-}
-
-describe('Pages Router Redis cache integration (two instances)', () => {
-  beforeAll(async () => {
-    // If old servers from a previous run are still around, kill them
-    for (const port of [INSTANCE_A_PORT, INSTANCE_B_PORT]) {
-      try {
-        const res = await fetch(`http://localhost:${port}`);
-        if (res.ok) {
-          await runCommand('pkill', ['-f', `next start -p ${port}`], '.');
-        }
-      } catch {}
-    }
-
-    // Set up environment variables
-    process.env.VERCEL_ENV = 'production';
-    process.env.VERCEL_URL =
-      'pages-integration-test-' + Math.random().toString(36).substring(2, 15);
-    console.log('redis key prefix is:', process.env.VERCEL_URL);
-
-    // Only override redis env vars if not set. This can be set in the CI env.
-    process.env.REDISHOST = process.env.REDISHOST || 'localhost';
-    process.env.REDISPORT = process.env.REDISPORT || '6379';
-
-    if (process.env.SKIP_BUILD === 'true') {
-      console.log('skipping build');
-    } else {
-      await runCommand('pnpm', ['i'], NEXT_APP_DIR);
-      console.log('pnpm i done');
-      await runCommand('pnpm', ['build'], NEXT_APP_DIR);
-      console.log('pnpm build done');
-    }
-
-    buildId = readFileSync(join(NEXT_APP_DIR, '.next', 'BUILD_ID'), 'utf-8')
-      .toString()
-      .trim();
-
-    // Start two Next.js instances of the same build sharing one Redis
-    instanceA = startInstance(INSTANCE_A_PORT);
-    instanceB = startInstance(INSTANCE_B_PORT);
-    await Promise.all([
-      waitForServer(INSTANCE_A_URL),
-      waitForServer(INSTANCE_B_URL),
-    ]);
-    console.log('both next instances started');
-
-    // Connect to Redis
-    redisClient = createClient({
-      url: `redis://${process.env.REDISHOST}:${process.env.REDISPORT}`,
-    });
-    await redisClient.connect();
-  }, 240_000);
-
-  afterAll(async () => {
-    if (process.env.KEEP_SERVER_RUNNING === 'true') {
-      console.log('keeping servers running');
-    } else {
-      if (instanceA) instanceA.kill();
-      if (instanceB) instanceB.kill();
-    }
-    if (redisClient) await redisClient.quit();
-  });
-
-  describe('PAGES entries (getStaticProps + revalidate)', () => {
-    let firstTimestamp: number;
-    let firstCounter: number;
-
-    it('first request on instance A renders the page and stores a PAGES entry in Redis', async () => {
-      const res = await fetch(INSTANCE_A_URL + '/isr/prebuilt');
-      expect(res.status).toBe(200);
-      const html = await res.text();
-      firstTimestamp = extractTimestamp(html);
-      firstCounter = extractCounter(html);
-
-      await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-      const value = (await redisClient.get(
-        process.env.VERCEL_URL + '/isr/prebuilt',
-      )) as string;
-      expect(value).toBeDefined();
-      const cacheEntry: CacheEntry = JSON.parse(value);
-      expect(cacheEntry).toMatchObject({
-        value: {
-          kind: 'PAGES',
-          html: expect.any(String),
-          pageData: {
-            pageProps: expect.objectContaining({
-              slug: 'prebuilt',
-              timestamp: firstTimestamp,
-            }),
-          },
-        },
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/isr/prebuilt'],
-      });
-
-      // The implicit path tag is registered in the shared tags hashmap so
-      // that revalidatePath()/revalidateTag() can invalidate the page
-      const hashmap = (await redisClient.hGet(
-        process.env.VERCEL_URL + '__sharedTags__',
-        '/isr/prebuilt',
-      )) as string;
-      expect(JSON.parse(hashmap)).toEqual(['_N_T_/isr/prebuilt']);
-    });
-
-    it('the TTL is derived from the getStaticProps revalidate value', async () => {
-      const ttl = await redisClient.ttl(
-        process.env.VERCEL_URL + '/isr/prebuilt',
-      );
-      expectIsrRedisTtl(ttl);
-    });
-
-    it('instance B serves the identical cached HTML from the shared Redis', async () => {
-      const res = await fetch(INSTANCE_B_URL + '/isr/prebuilt');
-      expect(res.status).toBe(200);
-      const html = await res.text();
-      expect(extractTimestamp(html)).toBe(firstTimestamp);
-      expect(extractCounter(html)).toBe(firstCounter);
-    });
-
-    it('the pageData JSON (client navigation) is served from the same entry', async () => {
-      const res = await fetch(
-        `${INSTANCE_B_URL}/_next/data/${buildId}/isr/prebuilt.json`,
-      );
-      expect(res.status).toBe(200);
-      const data: any = await res.json();
-      expect(data.pageProps.slug).toBe('prebuilt');
-      expect(data.pageProps.timestamp).toBe(firstTimestamp);
-    });
-
-    describe('two-instance on-demand revalidation (res.revalidate)', () => {
-      it('res.revalidate on instance A updates Redis and instance B serves the fresh HTML and pageData', async () => {
-        // Wait until instance B's in-memory deduplication cache entry for
-        // the page has expired, so its next get() hits Redis again
-        await delay(IN_MEMORY_CACHE_EXPIRY_DELAY);
-
-        const revalidateRes = await fetch(
-          INSTANCE_A_URL + '/api/revalidate?path=/isr/prebuilt',
-        );
-        const revalidateJson: any = await revalidateRes.json();
-        expect(revalidateJson).toEqual({
-          revalidated: true,
-          path: '/isr/prebuilt',
-        });
-
-        await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-        // Instance B must serve the fresh HTML rendered by instance A
-        const resB = await fetch(INSTANCE_B_URL + '/isr/prebuilt');
-        expect(resB.status).toBe(200);
-        const htmlB = await resB.text();
-        const timestampB = extractTimestamp(htmlB);
-        const counterB = extractCounter(htmlB);
-        expect(timestampB).toBeGreaterThan(firstTimestamp);
-
-        // Instance A serves the same regenerated page - both instances
-        // return the exact same render, proving it came through Redis and
-        // not from an independent re-render per instance
-        const resA = await fetch(INSTANCE_A_URL + '/isr/prebuilt');
-        const htmlA = await resA.text();
-        expect(extractTimestamp(htmlA)).toBe(timestampB);
-        expect(extractCounter(htmlA)).toBe(counterB);
-
-        // The updated pageData JSON for client-side navigation is also
-        // served fresh on instance B
-        const dataRes = await fetch(
-          `${INSTANCE_B_URL}/_next/data/${buildId}/isr/prebuilt.json`,
-        );
-        expect(dataRes.status).toBe(200);
-        const data: any = await dataRes.json();
-        expect(data.pageProps.timestamp).toBe(timestampB);
-      }, 30_000);
-    });
-  });
-
-  describe('fallback: "blocking" (page not prerendered at build time)', () => {
-    it('first hit renders the page (blocking) and stores it in Redis', async () => {
-      const res = await fetch(INSTANCE_A_URL + '/isr/fallback-test');
-      expect(res.status).toBe(200);
-      const html = await res.text();
-      const timestamp = extractTimestamp(html);
-
-      await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-      const value = (await redisClient.get(
-        process.env.VERCEL_URL + '/isr/fallback-test',
-      )) as string;
-      expect(value).toBeDefined();
-      const cacheEntry: CacheEntry = JSON.parse(value);
-      expect((cacheEntry.value as { kind: string }).kind).toBe('PAGES');
-
-      // The other instance serves the same render from Redis
-      const resB = await fetch(INSTANCE_B_URL + '/isr/fallback-test');
-      expect(resB.status).toBe(200);
-      expect(extractTimestamp(await resB.text())).toBe(timestamp);
-    });
-  });
-
-  describe('notFound: true (null cache entry)', () => {
-    it('renders a 404 and stores a null-value entry in Redis', async () => {
-      const res = await fetch(INSTANCE_A_URL + '/isr/not-found');
-      expect(res.status).toBe(404);
-
-      await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-      const value = (await redisClient.get(
-        process.env.VERCEL_URL + '/isr/not-found',
-      )) as string;
-      expect(value).toBeDefined();
-      const cacheEntry: CacheEntry = JSON.parse(value);
-      expect(cacheEntry).toEqual({
-        value: null,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/isr/not-found'],
-      });
-
-      // TTL: Next.js 16.3+ keys on cacheControl.expire (SWR-safe); older
-      // versions use estimateExpireAge(revalidate).
-      const ttl = await redisClient.ttl(
-        process.env.VERCEL_URL + '/isr/not-found',
-      );
-      expectIsrRedisTtl(ttl);
-    });
-
-    it('instance B serves the 404 from the shared cache', async () => {
-      const res = await fetch(INSTANCE_B_URL + '/isr/not-found');
-      expect(res.status).toBe(404);
-    });
-  });
-
-  describe('redirect (getStaticProps redirect return)', () => {
-    it('responds with a redirect and stores a REDIRECT entry in Redis', async () => {
-      const res = await fetch(INSTANCE_A_URL + '/isr/redirect', {
-        redirect: 'manual',
-      });
-      expect(res.status).toBe(307);
-      expect(res.headers.get('location')).toContain('/static-forever');
-
-      await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-      const value = (await redisClient.get(
-        process.env.VERCEL_URL + '/isr/redirect',
-      )) as string;
-      expect(value).toBeDefined();
-      const cacheEntry: CacheEntry = JSON.parse(value);
-      expect(cacheEntry).toMatchObject({
-        value: {
-          kind: 'REDIRECT',
-          props: expect.objectContaining({
-            pageProps: expect.objectContaining({
-              __N_REDIRECT: '/static-forever',
-              __N_REDIRECT_STATUS: 307,
-            }),
-          }),
-        },
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/isr/redirect'],
-      });
-    });
-
-    it('instance B serves the redirect from the shared cache', async () => {
-      const res = await fetch(INSTANCE_B_URL + '/isr/redirect', {
-        redirect: 'manual',
-      });
-      expect(res.status).toBe(307);
-      expect(res.headers.get('location')).toContain('/static-forever');
-    });
-  });
-
-  describe('revalidate: false (fully static page)', () => {
-    it('falls back to the defaultStaleAge based TTL', async () => {
-      const res = await fetch(INSTANCE_A_URL + '/static-forever');
-      expect(res.status).toBe(200);
-
-      await delay(REDIS_BACKGROUND_SYNC_DELAY);
-
-      const value = (await redisClient.get(
-        process.env.VERCEL_URL + '/static-forever',
-      )) as string;
-      expect(value).toBeDefined();
-      const cacheEntry: CacheEntry = JSON.parse(value);
-      expect((cacheEntry.value as { kind: string }).kind).toBe('PAGES');
-
-      const ttl = await redisClient.ttl(
-        process.env.VERCEL_URL + '/static-forever',
-      );
-      // VERCEL_ENV=production -> expire age is 2 * defaultStaleAge (14 days)
-      expect(ttl).toBeGreaterThan(2 * DEFAULT_STALE_AGE - 30);
-      expect(ttl).toBeLessThanOrEqual(2 * DEFAULT_STALE_AGE);
-    });
-  });
-});

package/test/vitest/unit/SyncedMap-orphan-cleanup.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { SyncedMap } from '../../../src/SyncedMap';
-
-class HashMockClient {
-  hash = new Map<string, string>();
-  stringKeys: string[] = [];
-  hDelCalls: string[][] = [];
-  isOpen = true;
-  isReady = true;
-
-  on() {
-    return this;
-  }
-
-  async connect() {
-    this.isOpen = true;
-    this.isReady = true;
-  }
-
-  async configGet() {
-    return { 'notify-keyspace-events': 'Exe' };
-  }
-
-  async subscribe() {}
-
-  async quit() {}
-
-  async disconnect() {
-    this.isOpen = false;
-    this.isReady = false;
-  }
-
-  duplicate() {
-    return new HashMockClient();
-  }
-
-  async hScan() {
-    return {
-      cursor: 0,
-      tuples: [...this.hash.entries()].map(([field, value]) => ({
-        field,
-        value,
-      })),
-    };
-  }
-
-  async scan() {
-    return { cursor: 0, keys: this.stringKeys };
-  }
-
-  async hSet(_key: string, field: string, value: string) {
-    this.hash.set(field, value);
-    return 1;
-  }
-
-  async hDel(_key: string, fields: string | string[]) {
-    const list = Array.isArray(fields) ? fields : [fields];
-    this.hDelCalls.push(list);
-    for (const field of list) {
-      this.hash.delete(field);
-    }
-    return list.length;
-  }
-
-  async publish() {
-    return 1;
-  }
-}
-
-describe('SyncedMap orphan cleanup', () => {
-  it('deletes hash fields whose names are not Redis string keys', async () => {
-    const client = new HashMockClient();
-    const map = new SyncedMap<number>({
-      client: client as never,
-      keyPrefix: 'app:',
-      redisKey: '__revalidated_tags__',
-      database: 0,
-      querySize: 50,
-      filterKeys: () => true,
-    });
-    await map.waitUntilReady();
-    await map.set('posts', 1);
-
-    client.stringKeys = ['app:some-cache-entry'];
-    await (map as any).initialSync();
-
-    expect(client.hDelCalls.flat()).toContain('posts');
-    expect(map.get('posts')).toBeUndefined();
-  });
-
-  it('keeps tag-manifest fields when withoutOrphanCleanup is set', async () => {
-    const client = new HashMockClient();
-    const map = new SyncedMap<number>({
-      client: client as never,
-      keyPrefix: 'app:',
-      redisKey: '__cacheComponents_revalidated_tags__',
-      database: 0,
-      querySize: 50,
-      filterKeys: () => true,
-      customizedSync: { withoutOrphanCleanup: true },
-    });
-    await map.waitUntilReady();
-    await map.set('posts', 1);
-
-    client.stringKeys = ['app:some-cache-entry'];
-    await (map as any).initialSync();
-
-    expect(client.hDelCalls).toEqual([]);
-    expect(map.get('posts')).toBe(1);
-  });
-});

package/test/vitest/unit/SyncedMap-reconnect-repro.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { SyncedMap } from '../../../src/SyncedMap';
-
-// Module-level knobs for the subscribe() mock so that behaviour persists
-// across the duplicate() clients created inside SyncedMap.
-let globalSubscribeCalls = 0;
-let globalSubscribeFailUntil = 0;
-
-class MockClient {
-  static nextId = 1;
-  id = MockClient.nextId++;
-  private errorHandlers: Set<(err: Error) => void | Promise<void>> = new Set();
-  quitShouldThrow = true;
-
-  isOpen = true;
-  isReady = true;
-
-  on(event: string, handler: (err: Error) => void | Promise<void>) {
-    if (event === 'error') this.errorHandlers.add(handler);
-    return this as any;
-  }
-
-  emit(event: string, err: Error) {
-    if (event === 'error') {
-      for (const h of this.errorHandlers) {
-        void h(err);
-      }
-    }
-    return true;
-  }
-
-  removeAllListeners(event?: string) {
-    if (!event || event === 'error') this.errorHandlers.clear();
-    return this as any;
-  }
-
-  async connect() {
-    this.isOpen = true;
-    this.isReady = true;
-  }
-
-  async configGet() {
-    return { 'notify-keyspace-events': 'Exe' };
-  }
-
-  async subscribe() {
-    const attempt = globalSubscribeCalls++;
-    if (attempt < globalSubscribeFailUntil) {
-      throw new Error(`Mock subscribe failure ${attempt}`);
-    }
-  }
-
-  async quit() {
-    if (this.quitShouldThrow)
-      throw new Error('Mock quit failure (disconnected)');
-  }
-
-  async disconnect() {
-    this.isOpen = false;
-    this.isReady = false;
-    this.errorHandlers.clear();
-  }
-
-  duplicate() {
-    return new MockClient();
-  }
-
-  hScan() {
-    return { cursor: 0, tuples: [] };
-  }
-
-  scan() {
-    return { cursor: 0, keys: [] };
-  }
-}
-
-function createMap(rootClient = new MockClient()) {
-  return new SyncedMap<string>({
-    client: rootClient as any,
-    keyPrefix: 'repro:',
-    redisKey: '__sharedTags__',
-    database: 0,
-    querySize: 250,
-    filterKeys: () => true,
-    customizedSync: {
-      withoutRedisHashmap: true,
-      withoutSetSync: true,
-    },
-  });
-}
-
-describe('SyncedMap.reconnectSubscriber() repro tests', () => {
-  let originalSetTimeout: typeof global.setTimeout;
-
-  beforeEach(() => {
-    globalSubscribeCalls = 0;
-    globalSubscribeFailUntil = 0;
-    originalSetTimeout = global.setTimeout;
-  });
-
-  afterEach(() => {
-    global.setTimeout = originalSetTimeout;
-  });
-
-  it('Issue 2: first backoff delay should be 500ms, not 1000ms', async () => {
-    const root = new MockClient();
-    const map = createMap(root);
-    // wait for initial setup to succeed (attempt 0)
-    await (map as any).waitUntilReady().catch(() => undefined);
-
-    const capturedDelays: number[] = [];
-    global.setTimeout = ((callback: () => void, delay?: number) => {
-      capturedDelays.push(Number(delay ?? 0));
-      return originalSetTimeout(callback, 0) as any;
-    }) as any;
-
-    // initial subscribe consumed attempt 0; force the next 3 reconnection
-    // attempts to fail, then succeed on the 4th
-    globalSubscribeFailUntil = 4;
-
-    await (map as any).reconnectSubscriber();
-
-    expect(capturedDelays.length).toBeGreaterThanOrEqual(1);
-    // Bug: delay is computed with attempt already incremented, so the first
-    // retry waits 500 * 2^1 = 1000 ms. After the fix it should be 500 ms.
-    expect(capturedDelays[0]).toBe(500);
-  });
-
-  it('Issue 1: stale error on old subscriber must not kill the healthy new subscriber', async () => {
-    const root = new MockClient();
-    const map = createMap(root);
-    await (map as any).waitUntilReady().catch(() => undefined);
-
-    const oldSubscriber = (map as any).subscriberClient as MockClient;
-    expect(oldSubscriber).toBeDefined();
-
-    await (map as any).reconnectSubscriber();
-
-    const newSubscriber = (map as any).subscriberClient as MockClient;
-    expect(newSubscriber.id).not.toBe(oldSubscriber.id);
-
-    // Simulate a delayed error from the old (now replaced) subscriber.
-    // With the current code the old 'error' listener is still attached,
-    // so it triggers reconnectSubscriber() and tears down the healthy client.
-    oldSubscriber.emit('error', new Error('delayed zombie error'));
-
-    // Give the async error handler a chance to run.
-    await new Promise((r) => originalSetTimeout(r, 50));
-
-    const afterStaleError = (map as any).subscriberClient as MockClient;
-
-    expect(afterStaleError.id).toBe(newSubscriber.id);
-  });
-});