@cosmicdrift/kumiko-testing 0.387.0 → 0.389.0

package/src/helpers/console-calls.ts

@@ -0,0 +1,21 @@
+export type ConsoleSpyLike = {
+  readonly mock: { readonly calls: ReadonlyArray<ReadonlyArray<unknown>> };
+};
+
+// Other test files in the same bun process emit async console output while a console spy is
+// active, so assertions only count the calls that mention the message under test.
+export function consoleCallsMentioning(
+  spy: ConsoleSpyLike,
+  fragment: string,
+): ReadonlyArray<ReadonlyArray<unknown>> {
+  return spy.mock.calls.filter((args) => args.some((arg) => String(arg).includes(fragment)));
+}
+
+// For "stays silent" assertions: counts every call from the given logger namespace instead of one
+// message text, so a new or reworded warning from the module under test still fails the test.
+export function consoleCallsFromNamespace(
+  spy: ConsoleSpyLike,
+  namespace: string,
+): ReadonlyArray<ReadonlyArray<unknown>> {
+  return spy.mock.calls.filter((args) => String(args[0]).startsWith(`[${namespace}]`));
+}

package/src/helpers/index.ts

@@ -23,6 +23,11 @@ export {
   terminateBackendsByApplicationName,
   testDatabaseUrl,
 } from "./closed-connection-error.ts";
+export {
+  type ConsoleSpyLike,
+  consoleCallsFromNamespace,
+  consoleCallsMentioning,
+} from "./console-calls.ts";
 export { type ClearableTable, clearTables, resetTestTables } from "./db-cleanup.ts";
 export {
   type E2EGeneratorOptions,

package/src/helpers/mock-module.ts

@@ -0,0 +1,24 @@
+import { afterAll, mock } from "bun:test";
+
+/**
+ * Mocks `specifier` with the real exports plus `overrides` and restores the real module in
+ * `afterAll`: bun's mock.module is process-global, so a leaked mock breaks later files of a
+ * shared DOM run. Pass the namespace imported before mocking; it is copied here because
+ * mock.module patches an already imported namespace in place. A relative specifier must be
+ * absolute (resolve it against the test file), since mock.module resolves it from this file.
+ *
+ * `restoreOverrides` fixes up modules that re-export a mocked binding: their copy was taken
+ * under the mock and holds the spy, so it must be pointed back at the real export.
+ */
+export function mockModuleForFile(
+  specifier: string,
+  realModule: object,
+  overrides: Readonly<Record<string, unknown>>,
+  options: { readonly restoreOverrides?: Readonly<Record<string, unknown>> } = {},
+): void {
+  const real = { ...realModule };
+  mock.module(specifier, () => ({ ...real, ...overrides }));
+  afterAll(() => {
+    mock.module(specifier, () => ({ ...real, ...options.restoreOverrides }));
+  });
+}

package/src/helpers/sse-frames.ts

@@ -25,6 +25,8 @@ export async function readSseFrames(
   const decoder = new TextDecoder();
   const frames: SseFrame[] = [];
   let buffer = "";
+  // A "\r" at a chunk end may be the first half of "\r\n", so it is held back until the next chunk.
+  let heldCarriageReturn: boolean = false;
   let timer: ReturnType<typeof setTimeout> | undefined;
   const timedOut = new Promise<never>((_, reject) => {
     timer = setTimeout(
@@ -40,7 +42,10 @@ export async function readSseFrames(
       if (chunk.done) {
         throw new Error(`sse stream ended before condition: ${frames.length} frames read`);
       }
-      buffer += decoder.decode(chunk.value, { stream: true });
+      const decodedText = decoder.decode(chunk.value, { stream: true });
+      const decoded: string = (heldCarriageReturn ? "\r" : "") + decodedText;
+      heldCarriageReturn = decoded.endsWith("\r");
+      buffer += (heldCarriageReturn ? decoded.slice(0, -1) : decoded).replace(/\r\n?/g, "\n");
       let separator = buffer.indexOf("\n\n");
       while (separator !== -1) {
         const rawFrame = buffer.slice(0, separator);

package/src/stack/db.ts

@@ -54,7 +54,7 @@ export function testDbTemplatePrefix(runId: string): string {
   return `kumiko_test_tpl_${runId}_`;
 }
 
-function adminUrlOf(url: string): string {
+export function adminUrlOf(url: string): string {
   return url.replace(/\/[^/]+$/, "/postgres");
 }
 
@@ -99,7 +99,7 @@ export async function createTestDb(arg?: string | CreateTestDbOptions): Promise<
     db: conn.db,
     poolMax,
     outsideTransactionDb: outsideConn.db,
-    client: conn.client,
+    client: conn.listenClient,
     dbName,
     cleanup: async () => {
       await conn.close();
@@ -132,7 +132,7 @@ export function ensureTestDbTemplate(
   return pending;
 }
 
-async function buildTestDbTemplate(
+export async function buildTestDbTemplate(
   templateDbName: string,
   buildSchema: (db: DbConnection) => Promise<void>,
 ): Promise<void> {

package/src/stack/redis.ts

@@ -40,7 +40,13 @@ export async function createTestRedis(opts: CreateTestRedisOptions = {}): Promis
   const prefix = opts.borrowKeyPrefix ?? `kt:${generateId().slice(-8)}:`;
   // Callers that check redis.status (rate-limit resolver) must not see "connect" on their first call.
   const redis = new Redis(redisUrl, { keyPrefix: prefix, lazyConnect: true });
-  await redis.connect();
+  try {
+    await redis.connect();
+  } catch (error) {
+    // Without this the client keeps retrying in the background and holds the process open.
+    redis.disconnect();
+    throw error;
+  }
 
   async function deleteKeysMatching(pattern: string): Promise<void> {
     // Open a prefix-less client for the scan — ioredis' keyPrefix is applied