@cosmicdrift/kumiko-testing 0.367.0 → 0.369.0

package/src/stack/db.ts

@@ -0,0 +1,94 @@
+// @runtime dev
+// Test-DB Factory: CREATE DATABASE → connect → createEventsTable.
+
+import { DEFAULT_OUTSIDE_TRANSACTION_POOL_MAX } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createDatabase,
+  createDbConnection,
+  databaseExists,
+  dropDatabaseIfExists,
+} from "@cosmicdrift/kumiko-framework/internal/stack-support";
+import { ensureTemporalPolyfill } from "@cosmicdrift/kumiko-framework/time";
+import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+import type { DbConnection, PgListenClient } from "@cosmicdrift/kumiko-types/db-connection";
+
+function requireEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(
+      `Missing required env var: ${name}. Copy .env.example to .env and fill in values. Tests also need the test services (Postgres, Redis) running, e.g. "docker compose up -d".`,
+    );
+  }
+  return value;
+}
+
+export type TestDb = {
+  db: DbConnection;
+  outsideTransactionDb: DbConnection;
+  client: PgListenClient;
+  dbName: string;
+  cleanup: () => Promise<void>;
+};
+
+export type CreateTestDbOptions = {
+  readonly baseUrl?: string;
+  readonly dbName?: string;
+  readonly persistent?: boolean;
+  readonly poolMax?: number;
+  readonly outsideTransactionPoolMax?: number;
+};
+
+export async function createTestDb(arg?: string | CreateTestDbOptions): Promise<TestDb> {
+  await ensureTemporalPolyfill();
+  const opts: CreateTestDbOptions = typeof arg === "string" ? { baseUrl: arg } : (arg ?? {});
+  const url = opts.baseUrl ?? requireEnv("TEST_DATABASE_URL");
+  const dbName = opts.dbName ?? `kumiko_test_${generateId().slice(-8)}`;
+  const adminUrl = url.replace(/\/[^/]+$/, "/postgres");
+
+  const admin = createDbConnection({ url: adminUrl, maxConnections: 1 });
+  try {
+    if (opts.persistent) {
+      if (!(await databaseExists(admin.db, dbName))) {
+        await createDatabase(admin.db, dbName);
+      }
+    } else {
+      await createDatabase(admin.db, dbName);
+    }
+  } finally {
+    await admin.close();
+  }
+
+  const testUrl = url.replace(/\/[^/]+$/, `/${dbName}`);
+  const conn = createDbConnection({
+    url: testUrl,
+    ...(opts.poolMax !== undefined ? { maxConnections: opts.poolMax } : {}),
+  });
+  const outsideConn = createDbConnection({
+    url: testUrl,
+    maxConnections: opts.outsideTransactionPoolMax ?? DEFAULT_OUTSIDE_TRANSACTION_POOL_MAX,
+  });
+
+  const { createEventsTable } = await import("@cosmicdrift/kumiko-framework/event-store");
+  await createEventsTable(conn.db);
+
+  return {
+    db: conn.db,
+    outsideTransactionDb: outsideConn.db,
+    client: conn.client,
+    dbName,
+    cleanup: async () => {
+      await conn.close();
+      await outsideConn.close();
+      if (!opts.persistent) {
+        const admin2 = createDbConnection({ url: adminUrl, maxConnections: 1 });
+        try {
+          await dropDatabaseIfExists(admin2.db, dbName);
+        } finally {
+          await admin2.close();
+        }
+      }
+    },
+  };
+}
+
+export { requireEnv };

package/src/stack/drain-event-consumers.ts

@@ -0,0 +1,81 @@
+// @runtime dev
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { getEventsHighWaterMark } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  type ConsumerRecoveryState,
+  getConsumerState,
+} from "@cosmicdrift/kumiko-framework/pipeline";
+import type { TestStack } from "./test-stack.js";
+
+const DEFAULT_MAX_PASSES = 25;
+
+// Drives eventDispatcher.runOnce() until every named consumer has caught up
+// to the events high-water mark captured at call time. No "no progress ⇒
+// throw" shortcut: a pass can legitimately advance zero cursors even though
+// work remains — runOnce's FOR UPDATE SKIP LOCKED lets a concurrent pass
+// (the test stack's own 50ms poll timer) hold a consumer's row, and a
+// consumer coming off a thrown-pass backoff sits idle until its retryAtMs
+// elapses. A bounded pass budget tolerates both without pretending to detect
+// "stuck" from a single empty pass. The target is a snapshot: events a
+// consumer's own handler writes afterward (cascades) are not waited on.
+export async function drainEventConsumers(
+  stack: Pick<TestStack, "db" | "eventDispatcher">,
+  consumerNames: readonly [string, ...string[]],
+  options?: { readonly maxPasses?: number },
+): Promise<void> {
+  const { db, eventDispatcher } = stack;
+  if (!eventDispatcher) {
+    throw new Error(
+      "drainEventConsumers: stack.eventDispatcher is undefined — no system consumer or " +
+        "multiStreamProjection is wired for this stack.",
+    );
+  }
+  const maxPasses = options?.maxPasses ?? DEFAULT_MAX_PASSES;
+  if (!Number.isInteger(maxPasses) || maxPasses < 1) {
+    throw new Error("drainEventConsumers: maxPasses must be a positive integer");
+  }
+  const target = await getEventsHighWaterMark(db);
+
+  for (let pass = 0; pass < maxPasses; pass++) {
+    await eventDispatcher.runOnce();
+    const states = await loadConsumerStates(db, consumerNames);
+    // skip: every named consumer has already caught up to the target snapshot — the
+    // remaining budgeted passes are unnecessary, not a swallowed error.
+    if (states.every((state) => state.lastProcessedEventId >= target)) return;
+    if (pass === maxPasses - 1) {
+      throw budgetExhaustedError(maxPasses, target, states);
+    }
+  }
+}
+
+async function loadConsumerStates(
+  db: DbConnection,
+  consumerNames: readonly [string, ...string[]],
+): Promise<readonly ConsumerRecoveryState[]> {
+  return Promise.all(
+    consumerNames.map(async (name) => {
+      const state = await getConsumerState(db, name);
+      if (!state) {
+        throw new Error(`drainEventConsumers: consumer "${name}" not registered or per-instance`);
+      }
+      return state;
+    }),
+  );
+}
+
+function budgetExhaustedError(
+  maxPasses: number,
+  target: bigint,
+  states: readonly ConsumerRecoveryState[],
+): Error {
+  const unfinished = states.filter((state) => state.lastProcessedEventId < target);
+  const lines = unfinished.map(
+    (state) =>
+      `  ${state.name}: lastProcessedEventId=${state.lastProcessedEventId} target=${target} ` +
+      `status=${state.status} attempts=${state.attempts} lastError=${state.lastError ?? "null"}`,
+  );
+  return new Error(
+    `drainEventConsumers: budget of ${maxPasses} passes exhausted, consumers still behind target:\n` +
+      lines.join("\n"),
+  );
+}

package/src/stack/drain-jobs.ts

@@ -0,0 +1,188 @@
+// @runtime dev
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { getEventsHighWaterMark } from "@cosmicdrift/kumiko-framework/event-store";
+import type { JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import { type EventDispatcher, getConsumerState } from "@cosmicdrift/kumiko-framework/pipeline";
+
+// Gap between idle-checks while waiting for a job hook to fire. Short enough
+// that a test never feels it, long enough that consecutive idle passes don't
+// hammer Postgres/Redis with pointless polling between hook-driven wakeups.
+const DRAIN_IDLE_POLL_MS = 25;
+// Two consecutive idle passes (not one) before declaring the stack drained —
+// a single "pending===0 and consumers caught up" pass can be a race: a job
+// hook fires and enqueues a follow-up between the countPendingJobs() read
+// and the consumer check of the SAME pass. A DRAIN_IDLE_POLL_MS wait sits
+// between every pass, including the first and second idle one, so an
+// enqueue that lands just after the first idle read still gets picked up
+// by the second pass instead of racing straight past it.
+const REQUIRED_IDLE_PASSES = 2;
+// Below the 15s per-test budget so a stuck drain reports what is open rather
+// than surfacing as a bare test timeout.
+const DEFAULT_DRAIN_TIMEOUT_MS = 10_000;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export type JobFailureTracker = {
+  readonly onJobComplete: (jobName: string, jobId: string) => void;
+  readonly onJobFailed: (jobName: string, jobId: string, error: string) => void;
+  waitForActivity(): Promise<void>;
+  readonly failures: ReadonlyMap<string, { readonly jobName: string; readonly error: string }>;
+  clear(): void;
+};
+
+export function createJobFailureTracker(): JobFailureTracker {
+  const failures = new Map<string, { jobName: string; error: string }>();
+  let wake: (() => void) | undefined;
+  let armed: Promise<void> | undefined;
+
+  function fire(): void {
+    wake?.();
+    armed = undefined;
+    wake = undefined;
+  }
+
+  return {
+    onJobComplete(_jobName, jobId) {
+      // A retry that eventually succeeds must not leave a stale failure
+      // behind from its earlier attempt(s).
+      failures.delete(jobId);
+      fire();
+    },
+    onJobFailed(jobName, jobId, error) {
+      failures.set(jobId, { jobName, error });
+      fire();
+    },
+    waitForActivity() {
+      armed ??= new Promise<void>((resolve) => {
+        wake = resolve;
+      });
+      return armed;
+    },
+    failures,
+    clear() {
+      failures.clear();
+    },
+  };
+}
+
+export type DrainJobsStack = {
+  readonly db: DbConnection;
+  readonly eventDispatcher?: EventDispatcher;
+  readonly jobRunner?: JobRunner;
+};
+
+// Diagnostic only: lets the deadline error name what was still open.
+async function describeLaggingConsumers(
+  db: DbConnection,
+  consumerNames: readonly string[],
+): Promise<readonly string[]> {
+  // skip: no shared consumers wired — nothing to catch up on.
+  if (consumerNames.length === 0) return [];
+  const target = await getEventsHighWaterMark(db);
+  const lagging: string[] = [];
+  for (const name of consumerNames) {
+    const state = await getConsumerState(db, name);
+    if (state && state.lastProcessedEventId < target) {
+      lagging.push(
+        `${name} (status=${state.status}, lastProcessedEventId=${state.lastProcessedEventId}, target=${target})`,
+      );
+    }
+  }
+  return lagging;
+}
+
+async function drainTimeoutError(
+  db: DbConnection,
+  consumerNames: readonly string[],
+  timeoutMs: number,
+  pending: number,
+): Promise<Error> {
+  const lagging = await describeLaggingConsumers(db, consumerNames);
+  return new Error(
+    `drainJobs: not drained after ${timeoutMs}ms — pending jobs: ${pending}, ` +
+      `consumers behind: ${lagging.length === 0 ? "none" : lagging.join("; ")}`,
+  );
+}
+
+async function sharedConsumersCaughtUp(
+  db: DbConnection,
+  consumerNames: readonly string[],
+): Promise<boolean> {
+  // skip: no shared consumers wired — nothing to catch up on.
+  if (consumerNames.length === 0) return true;
+  const target = await getEventsHighWaterMark(db);
+  let allCaughtUp = true;
+  for (const name of consumerNames) {
+    const state = await getConsumerState(db, name);
+    if (!state) {
+      throw new Error(`drainJobs: consumer "${name}" not registered or per-instance`);
+    }
+    if (state.status === "dead") {
+      throw new Error(
+        `drainJobs: consumer "${state.name}" is dead — lastError: ${state.lastError ?? "unknown"}`,
+      );
+    }
+    if (state.lastProcessedEventId < target) allCaughtUp = false;
+  }
+  return allCaughtUp;
+}
+
+// Fails a stuck drain with a diagnosis instead of a generic test-runner timeout.
+// It only bounds the loop; it never replaces waiting for real work.
+export async function drainJobs(
+  stack: DrainJobsStack,
+  tracker: JobFailureTracker,
+  options?: { readonly timeoutMs?: number },
+): Promise<void> {
+  const { db, eventDispatcher, jobRunner } = stack;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  if (!jobRunner) {
+    throw new Error(
+      "drainJobs: stack.jobRunner is undefined — pass `jobs: {...}` to setupTestStack and " +
+        "register at least one r.job(...) so a runner is built.",
+    );
+  }
+
+  const sharedConsumerNames = (eventDispatcher?.consumers ?? [])
+    .filter((consumer) => (consumer.delivery ?? "shared") === "shared")
+    .map((consumer) => consumer.name);
+
+  try {
+    try {
+      let consecutiveIdlePasses = 0;
+      while (consecutiveIdlePasses < REQUIRED_IDLE_PASSES) {
+        await eventDispatcher?.runOnce();
+        const pending = await jobRunner.countPendingJobs();
+        const caughtUp = await sharedConsumersCaughtUp(db, sharedConsumerNames);
+        consecutiveIdlePasses = pending === 0 && caughtUp ? consecutiveIdlePasses + 1 : 0;
+        if (consecutiveIdlePasses < REQUIRED_IDLE_PASSES) {
+          if (Date.now() > deadline) {
+            throw await drainTimeoutError(db, sharedConsumerNames, timeoutMs, pending);
+          }
+          await Promise.race([tracker.waitForActivity(), sleep(DRAIN_IDLE_POLL_MS)]);
+        }
+      }
+    } catch (err) {
+      // A failed job often kills its consumer, so the drain error is only the follow-up symptom.
+      if (tracker.failures.size === 0) throw err;
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`${message}; ${describeJobFailures(tracker)}`, { cause: err });
+    }
+
+    if (tracker.failures.size > 0) {
+      throw new Error(`drainJobs: ${describeJobFailures(tracker)}`);
+    }
+  } finally {
+    tracker.clear();
+  }
+}
+
+function describeJobFailures(tracker: JobFailureTracker): string {
+  const details = [...tracker.failures.values()]
+    .map((failure) => `${failure.jobName}: ${failure.error}`)
+    .join("; ");
+  return `job(s) failed: ${details}`;
+}

package/src/stack/event-collector.ts

@@ -0,0 +1,24 @@
+// @runtime dev
+import type { SseEvent } from "@cosmicdrift/kumiko-framework/api";
+import type { SaveContext } from "@cosmicdrift/kumiko-framework/engine";
+
+export type EventCollector = {
+  readonly sse: SseEvent[];
+  readonly postSave: SaveContext[];
+  /** Clears all collected events — call in beforeEach for per-test isolation */
+  reset(): void;
+};
+
+export function createEventCollector(): EventCollector {
+  const sse: SseEvent[] = [];
+  const postSave: SaveContext[] = [];
+
+  return {
+    sse,
+    postSave,
+    reset() {
+      sse.length = 0;
+      postSave.length = 0;
+    },
+  };
+}

package/src/stack/index.ts

@@ -0,0 +1,28 @@
+// @runtime dev
+// Runtime-safe stack builder. The dev-server uses what lives here to boot a
+// complete Kumiko instance: DB, Redis, Hono app, dispatcher, SSE broker. The
+// files are historically named `test*` (createTestDb, setupTestStack,
+// TestUsers, …) but serve dev AND test code today: it is the same boot path,
+// once with an ephemeral DB (test) and once with a persistent DB (dev).
+//
+// Important: this module must contain NO vitest imports and must not pull
+// vitest-only helpers in transitively, or every tool that loads the dev-server
+// under Node (drizzle-kit, build scripts) crashes.
+
+export {
+  unsafeCreateEntityTable,
+  unsafeEnsureEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/internal/stack-support";
+export {
+  type CreateTestDbOptions,
+  createTestDb,
+  type TestDb,
+} from "./db.js";
+export { drainEventConsumers } from "./drain-event-consumers.js";
+export { createEventCollector, type EventCollector } from "./event-collector.js";
+export { pushEntityProjectionTables } from "./push-entity-projection-tables.js";
+export { createTestRedis, type TestRedis } from "./redis.js";
+export { createRequestHelper, type RequestHelper } from "./request-helper.js";
+export { resetEventStore } from "./table-helpers.js";
+export { setupTestStack, type TestStack, type TestStackOptions } from "./test-stack.js";

package/src/stack/push-entity-projection-tables.ts

@@ -0,0 +1,102 @@
+// @runtime dev
+import type { ColumnMeta, DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { tableExists } from "@cosmicdrift/kumiko-framework/db";
+import type { Registry } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  addMissingColumns,
+  addMissingIndexes,
+  columnNamesOf,
+  schemaTableName,
+  tableToMeta,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/internal/stack-support";
+
+type DbHolder = { readonly db: DbConnection };
+
+// biome-ignore lint/suspicious/noConsole: stack-internal status logging
+const logInfo = (msg: string): void => console.log(msg);
+
+/**
+ * Push all implicit-projection tables — one per `r.entity()` — that the
+ * registry knows about. setupTestStack already handles explicit
+ * projections, MSPs, and `r.storeTable()` declarations in its own loop;
+ * implicit projections are the missing piece for a fresh boot.
+ *
+ * Idempotent via `tableExists` so a persistent dev DB
+ * (`KUMIKO_DEV_DB_NAME`) reuses existing tables on reboot. One batched
+ * push at the end so drizzle-kit's `generateMigration` runs once over
+ * the whole missing set.
+ *
+ * Lives next to `setupTestStack` because both are stack-bootstrap
+ * helpers that legitimately speak the `unsafe*`-DDL layer; the
+ * Table-DDL Guard's stack/** allowlist is the single shared exemption
+ * site. Apps still declare data via `r.entity()` / `r.storeTable()` and
+ * never call this directly.
+ */
+export async function pushEntityProjectionTables(
+  stack: DbHolder,
+  registry: Registry,
+): Promise<void> {
+  const seen = new Set<unknown>();
+  const missing: Record<string, unknown> = {};
+
+  for (const [projName, proj] of registry.getAllProjections()) {
+    if (!proj.isImplicit) continue;
+    if (seen.has(proj.table)) continue;
+    seen.add(proj.table);
+    const physical = schemaTableName(proj.table) ?? tableToMeta(proj.table).tableName;
+    if (!(await tableExists(stack.db, `public.${physical}`))) {
+      missing[projName] = proj.table;
+      continue;
+    }
+    await syncExistingProjectionTable(stack, physical, proj.table);
+  }
+
+  if (Object.keys(missing).length > 0) {
+    await unsafePushTables(stack.db, missing);
+  }
+}
+
+function isUnsafeToAutoAdd(col: ColumnMeta): boolean {
+  return col.notNull && !col.primaryKey && col.defaultSql === undefined;
+}
+
+// Backfills columns and indexes a persistent dev DB predates; a required column with no
+// default can't be added safely on a table that may hold rows, so that
+// stays a boot error instead.
+async function syncExistingProjectionTable(
+  stack: DbHolder,
+  physical: string,
+  table: unknown,
+): Promise<void> {
+  const meta = tableToMeta(table);
+  const liveColumns = await columnNamesOf(stack.db, physical);
+  const missingColumns = meta.columns.filter((c) => !liveColumns.has(c.name));
+  if (missingColumns.length === 0) {
+    logInfo(`[kumiko-stack] table ${physical} already exists — skipping create`);
+    await addMissingIndexes(stack.db, physical, meta.indexes);
+    // skip: table is already in sync, only indexes needed backfilling
+    return;
+  }
+
+  const unsafeColumns = missingColumns.filter(isUnsafeToAutoAdd);
+  if (unsafeColumns.length > 0) {
+    const devDbName = process.env["KUMIKO_DEV_DB_NAME"] ?? "<KUMIKO_DEV_DB_NAME>";
+    throw new Error(
+      `[kumiko-stack] table "${physical}" is missing required column(s) ` +
+        `${unsafeColumns.map((c) => `"${c.name}"`).join(", ")} with no default. ` +
+        "Auto-sync only backfills nullable columns or columns with a default on an " +
+        "existing dev DB — a required column with no default can't be added safely " +
+        `once the table may hold rows. Drop the persistent dev database "${devDbName}" ` +
+        `(e.g. \`dropdb ${devDbName}\`, adjusted for your local Postgres host/port/user) ` +
+        "so the next boot recreates it from scratch.",
+    );
+  }
+
+  logInfo(
+    `[kumiko-stack] table ${physical} is missing column(s) ` +
+      `${missingColumns.map((c) => `"${c.name}"`).join(", ")} — adding`,
+  );
+  await addMissingColumns(stack.db, physical, missingColumns);
+  await addMissingIndexes(stack.db, physical, meta.indexes);
+}

package/src/stack/redis.ts

@@ -0,0 +1,78 @@
+// @runtime dev
+import { generateId } from "@cosmicdrift/kumiko-framework/utils";
+import { requireEnv } from "./db.js";
+
+export type TestRedis = {
+  redis: import("ioredis").Redis;
+  // The exact REDIS_URL used to build `redis` above — for a second, unrelated
+  // connection (e.g. the test-stack's JobRunner) that needs its own client
+  // rather than sharing this one's keyPrefix. Reconstructing a URL from
+  // `redis.options` loses password/username/tls/path (pr-review
+  // kumiko-framework #1036/2) — callers needing a fresh connection should use
+  // this raw string, not rebuild one from parsed options.
+  redisUrl: string;
+  /** The per-test `keyPrefix` on `redis`, e.g. `kt:1a2b3c4d:`. */
+  keyPrefix: string;
+  /** Delete every key this test created (prefix-scoped). Replaces the old
+   *  `redis.flushdb()` — that wiped other parallel tests' BullMQ state. */
+  flushNamespace: () => Promise<void>;
+  cleanup: () => Promise<void>;
+};
+
+// BullMQ queues live on the raw redisUrl, outside the test Redis keyPrefix, so
+// parallel stacks sharing the prod default queue name would consume each
+// other's jobs. BullMQ rejects `:` in queue names.
+export function queueNamePrefixForTestRedis(keyPrefix: string): string {
+  return keyPrefix.split(":").filter(Boolean).join("-");
+}
+
+export type CreateTestRedisOptions = {
+  /** Reuse another stack's keyPrefix on a fresh connection. cleanup() then only
+   *  disconnects — the owning stack flushes the namespace and its queues. */
+  readonly borrowKeyPrefix?: string;
+};
+
+export async function createTestRedis(opts: CreateTestRedisOptions = {}): Promise<TestRedis> {
+  const Redis = (await import("ioredis")).Redis;
+  const redisUrl = requireEnv("REDIS_URL");
+  // Every test gets a per-file key prefix on a shared DB (no DB-pool-of-15
+  // round-robin). Collisions at birthday-paradox rates are gone — the
+  // prefix space is unbounded. See Track B.3 in docs/plans/tests-refactor.
+  const prefix = opts.borrowKeyPrefix ?? `kt:${generateId().slice(-8)}:`;
+  const redis = new Redis(redisUrl, { keyPrefix: prefix });
+
+  async function deleteKeysMatching(pattern: string): Promise<void> {
+    // Open a prefix-less client for the scan — ioredis' keyPrefix is applied
+    // per-command but SCAN's returned keys are full names, so managing the
+    // del set with the prefix already on the connection is error-prone.
+    const raw = new Redis(redisUrl);
+    try {
+      const stream = raw.scanStream({ match: pattern, count: 500 });
+      const keys: string[] = [];
+      for await (const batch of stream) keys.push(...batch);
+      if (keys.length > 0) await raw.del(...keys);
+    } finally {
+      raw.disconnect();
+    }
+  }
+
+  const flushNamespace = (): Promise<void> => deleteKeysMatching(`${prefix}*`);
+
+  return {
+    redis,
+    redisUrl,
+    keyPrefix: prefix,
+    flushNamespace,
+    cleanup: async () => {
+      if (opts.borrowKeyPrefix !== undefined) {
+        redis.disconnect();
+        // skip: the owning stack flushes the shared namespace and its queues
+        return;
+      }
+      await flushNamespace();
+      // The derived per-stack JobRunner queues sit outside the keyPrefix.
+      await deleteKeysMatching(`bull:${queueNamePrefixForTestRedis(prefix)}-*`);
+      redis.disconnect();
+    },
+  };
+}