@zgeoff/atc 3.4.0 → 3.4.2

package/src/test-utils/start-stub-dropping-daemon.ts

@@ -6,6 +6,7 @@ import {
   decodeMessage,
   encodeMessage,
 } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface DroppingDaemonOptions {
   // The features the first handshake announces.
@@ -23,8 +24,9 @@ interface DroppingDaemonOptions {
  * and answers every later one with a session `s-1`. `keys` records the
  * idempotency key each of those requests carried, `undefined` for one that
  * carried none. `reads` counts the reads it has taken from every connection,
- * so a test can wait until one piece of a split write has arrived. Stop it
- * with `stop`, or hold it with `using`.
+ * so a test can wait until one piece of a split write has arrived. It stops
+ * once the current test finishes, so it must run inside a test; `stop` or
+ * disposal stops it sooner, and a second stop does nothing.
  */
 export function startStubDroppingDaemon(socketPath: string, options: DroppingDaemonOptions) {
   const keys: unknown[] = [];
@@ -88,16 +90,16 @@ export function startStubDroppingDaemon(socketPath: string, options: DroppingDae
     },
   });
 
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
   return {
     keys,
     get reads() {
       return reads;
     },
-    stop() {
-      server.stop(true);
-    },
-    [Symbol.dispose]() {
-      server.stop(true);
-    },
+    stop,
+    [Symbol.dispose]: stop,
   };
 }

package/src/test-utils/start-stub-impd-info.ts

@@ -1,10 +1,14 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 /**
  * An impd stand-in on a real HTTP port of the loopback address. Every call
  * is answered with HTTP 200 and the body impd's RPC sends for system info,
  * `{ json: info }`, so a client reads `info.features` as impd's features;
  * the test sets `info.features` to what impd should report. `paths` holds
- * the request path of each call, in order. Disposal stops the server; the
- * asynchronous form resolves once it has stopped.
+ * the request path of each call, in order. The server stops once the
+ * current test finishes, so it must run inside a test; disposal stops it
+ * sooner, the asynchronous form resolving once it has stopped, and a second
+ * stop does nothing.
  */
 export function startStubImpdInfo() {
   const paths: string[] = [];
@@ -20,13 +24,15 @@ export function startStubImpdInfo() {
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${String(server.port)}`,
     paths,
     info,
     [Symbol.dispose]: () => {
-      void server.stop(true);
+      void stop();
     },
-    [Symbol.asyncDispose]: () => server.stop(true),
+    [Symbol.asyncDispose]: stop,
   };
 }

package/src/test-utils/start-stub-impd.ts

@@ -1,5 +1,6 @@
 import type { ServerWebSocket } from 'bun';
 import { isRecord } from '../shared/report';
+import { registerTestCleanup } from './register-test-cleanup';
 
 // What the stand-in does with an exec open: refuse it as a start whose
 // broker is not ready, start it and count its stdin bytes as `wc -c` does,
@@ -15,8 +16,10 @@ type StubExecReply = 'refuse' | 'count' | 'exit-early';
  * announce a guest connection on it. It records each exec open message in
  * `execOpens` and answers it as `exec.reply` says, a refusal as a start
  * whose broker is not ready by default. It takes no WebSocket message over
- * 2 MiB, as impd refuses one over its own limit. Disposal stops the server
- * and drops every open connection at once.
+ * 2 MiB, as impd refuses one over its own limit. The server stops, dropping
+ * every open connection at once, when the current test finishes, so it must
+ * run inside a test; disposal stops it sooner, and a second stop does
+ * nothing.
  */
 export function startStubImpd() {
   const authorizations: (string | null)[] = [];
@@ -123,6 +126,8 @@ export function startStubImpd() {
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${String(server.port)}`,
     authorizations,
@@ -132,7 +137,7 @@ export function startStubImpd() {
     execOpens,
     exec,
     [Symbol.dispose]: () => {
-      void server.stop(true);
+      void stop();
     },
   };
 }

package/src/test-utils/start-stub-legacy-daemon.ts

@@ -7,6 +7,7 @@ import {
   decodeMessage,
   encodeMessage,
 } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface ReceivedRequest {
   readonly m: string;
@@ -28,6 +29,11 @@ interface StubLegacyDaemonOptions {
   readonly protocol?: number;
 
   readonly replies?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+
+  // Who stops the daemon: the current test, once it finishes, or the
+  // caller alone, for a process that runs it outside any test; the test
+  // unless set.
+  readonly owner?: 'test' | 'caller';
 }
 
 /**
@@ -39,8 +45,10 @@ interface StubLegacyDaemonOptions {
  * `replies` with that method's reply, and refuses every other method with
  * `unknown_method`. Every request it receives is recorded in `requests`, and
  * `connections` counts the connections it accepted and those still open.
- * `port` holds the TCP port it bound, `null` on a unix socket. Stop
- * it with `stop`, or hold it with `using`.
+ * `port` holds the TCP port it bound, `null` on a unix socket. It stops
+ * once the current test finishes, so it must run inside a test, unless the
+ * options make the caller its owner; `stop` or disposal stops it sooner, and
+ * a second stop does nothing.
  */
 export function startStubLegacyDaemon(
   address: string | StubLegacyDaemonTCPAddress,
@@ -120,17 +128,14 @@ export function startStubLegacyDaemon(
   };
 
   const server = startListener(address, handlers);
+  const stop = options.owner === 'caller' ? server.stop : registerTestCleanup(server.stop);
 
   return {
     requests,
     connections,
     port: server.port,
-    stop() {
-      server.stop();
-    },
-    [Symbol.dispose]() {
-      server.stop();
-    },
+    stop,
+    [Symbol.dispose]: stop,
   };
 }
 

package/src/test-utils/start-stub-mcp-server.ts

@@ -1,3 +1,5 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 interface StubMCPRequest {
   readonly method: string;
   readonly path: string;
@@ -19,7 +21,8 @@ interface StubMCPServer {
  * A stand-in for an MCP HTTP server on a loopback port: it answers every
  * request with the JSON body given, and records each request's method,
  * path, authorization and content-type headers, and JSON body. `url` holds
- * its origin. Disposal stops it; hold the result with `using`.
+ * its origin. It stops once the current test finishes, so it must run
+ * inside a test; disposal stops it sooner, and a second stop does nothing.
  */
 export function startStubMCPServer(answer: unknown): StubMCPServer {
   const requests: StubMCPRequest[] = [];
@@ -40,11 +43,13 @@ export function startStubMCPServer(answer: unknown): StubMCPServer {
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${String(server.port)}`,
     requests,
     [Symbol.dispose]: () => {
-      void server.stop(true);
+      void stop();
     },
   };
 }

package/src/test-utils/start-stub-recording-listener.ts

@@ -0,0 +1,47 @@
+import type { Socket } from 'bun';
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubRecordingListener {
+  // Resolves with the server's side of the first connection it accepts.
+  readonly accepted: Promise<Socket>;
+
+  // What each read took from any connection, decoded, in arrival order.
+  readonly received: readonly string[];
+  readonly [Symbol.dispose]: () => void;
+}
+
+/**
+ * A stand-in for a peer that a test writes through: it listens on the unix
+ * socket path, hands the test the server's side of the first connection it
+ * accepts, records what each read takes from any connection, and sends
+ * nothing of its own. It stops, dropping every connection it holds, once
+ * the current test finishes, so it must run inside a test; disposal stops it
+ * sooner, and a second stop does nothing.
+ */
+export function startStubRecordingListener(path: string): StubRecordingListener {
+  const accepted = Promise.withResolvers<Socket>();
+  const received: string[] = [];
+
+  const server = Bun.listen({
+    unix: path,
+    socket: {
+      open(socket) {
+        accepted.resolve(socket);
+      },
+      data(_socket, data) {
+        received.push(data.toString());
+      },
+      error() {},
+    },
+  });
+
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
+  return {
+    accepted: accepted.promise,
+    received,
+    [Symbol.dispose]: stop,
+  };
+}

package/src/test-utils/start-stub-refusing-listener.ts

@@ -1,3 +1,5 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 interface StubRefusingListener {
   readonly port: number;
 
@@ -11,7 +13,8 @@ interface StubRefusingListener {
  * A stand-in for a daemon's TCP listener refusing a connection whose first
  * line is not a handshake: on a loopback port, it records what each read
  * takes from a connection and ends that connection, answering nothing.
- * Disposal stops it; hold the result with `using`.
+ * It stops once the current test finishes, so it must run inside a test;
+ * disposal stops it sooner, and a second stop does nothing.
  */
 export function startStubRefusingListener(): StubRefusingListener {
   const received: string[] = [];
@@ -28,11 +31,13 @@ export function startStubRefusingListener(): StubRefusingListener {
     },
   });
 
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
   return {
     port: server.port,
     received,
-    [Symbol.dispose]: () => {
-      server.stop(true);
-    },
+    [Symbol.dispose]: stop,
   };
 }

package/src/test-utils/start-stub-reporter-socket.ts

@@ -1,3 +1,4 @@
+import { registerTestCleanup } from './register-test-cleanup';
 import { waitFor } from './wait-for';
 
 interface StubReporterSocket {
@@ -19,8 +20,9 @@ interface StubReporterSocket {
  * hook and report commands send. It never writes back, and leaves each
  * connection for the sender to close. `waitForLine` resolves with the first
  * line once one has arrived, and rejects naming the socket when none arrives
- * within `timeoutMs`, 5 seconds by default. Disposal stops the listener; hold the
- * result with `using` or `await using`.
+ * within `timeoutMs`, 5 seconds by default. The listener stops once the
+ * current test finishes, so it must run inside a test; disposal stops it
+ * sooner, and a second stop does nothing.
  */
 export function startStubReporterSocket(path: string): StubReporterSocket {
   const lines: string[] = [];
@@ -45,9 +47,9 @@ export function startStubReporterSocket(path: string): StubReporterSocket {
     },
   });
 
-  const stop = () => {
+  const stop = registerTestCleanup(() => {
     server.stop(true);
-  };
+  });
 
   return {
     lines,

package/src/test-utils/start-stub-restore-daemon.ts

@@ -1,5 +1,6 @@
 import { LineDecoder } from '../protocol/line-decoder';
 import { PROTOCOL_V, decodeMessage, encodeMessage } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
 
 /**
  * A daemon stand-in on a unix socket path that speaks the real wire format
@@ -7,8 +8,8 @@ import { PROTOCOL_V, decodeMessage, encodeMessage } from '../protocol/protocol';
  * result, answers each other request with the next reply the test pushes
  * onto `lists`, and withholds the answer to any request that finds `lists`
  * empty. `methods` holds the method of each request it took, in order.
- * Disposal stops the listener; hold the result with `using` or
- * `await using`.
+ * The listener stops once the current test finishes, so it must run inside
+ * a test; disposal stops it sooner, and a second stop does nothing.
  */
 export function startStubRestoreDaemon(socketPath: string) {
   const lists: Readonly<Record<string, unknown>>[] = [];
@@ -41,9 +42,9 @@ export function startStubRestoreDaemon(socketPath: string) {
     },
   });
 
-  const stop = () => {
+  const stop = registerTestCleanup(() => {
     server.stop(true);
-  };
+  });
 
   return {
     lists,

package/src/test-utils/start-stub-session-bridge.ts

@@ -1,4 +1,5 @@
 import { isRecord } from '../shared/report';
+import { registerTestCleanup } from './register-test-cleanup';
 
 type BridgeRequest = Readonly<Record<string, unknown>>;
 
@@ -26,8 +27,9 @@ interface StubSessionBridge {
  * `tap.open` request with `ok` under the request's id as the real bridge
  * does once it attaches the tap, and hands every other request to the
  * responder, writing back each line it returns. A line that is not a JSON
- * object reaches the responder as an empty request. Disposal stops the
- * listener; hold the result with `using` or `await using`.
+ * object reaches the responder as an empty request. The listener stops once
+ * the current test finishes, so it must run inside a test; disposal stops it
+ * sooner, and a second stop does nothing.
  */
 export function startStubSessionBridge(path: string, respond: BridgeResponder): StubSessionBridge {
   const requests: BridgeRequest[] = [];
@@ -69,9 +71,9 @@ export function startStubSessionBridge(path: string, respond: BridgeResponder):
     },
   });
 
-  const stop = () => {
+  const stop = registerTestCleanup(() => {
     server.stop(true);
-  };
+  });
 
   return {
     requests,

package/src/test-utils/start-stub-silent-server.ts

@@ -1,9 +1,12 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 /**
  * An HTTP stand-in for an upstream that hangs: it listens on a real port of
  * the loopback address, takes every request, and never answers one. `paths`
- * holds the request path of each request it took, in order. Disposal stops
- * the server and drops the connections it holds; the asynchronous form
- * resolves once it has stopped.
+ * holds the request path of each request it took, in order. The server
+ * stops, dropping the connections it holds, once the current test finishes,
+ * so it must run inside a test; disposal stops it sooner, the asynchronous
+ * form resolving once it has stopped, and a second stop does nothing.
  */
 export function startStubSilentServer() {
   const paths: string[] = [];
@@ -22,12 +25,14 @@ export function startStubSilentServer() {
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${String(server.port)}/`,
     paths,
     [Symbol.dispose]: () => {
-      void server.stop(true);
+      void stop();
     },
-    [Symbol.asyncDispose]: () => server.stop(true),
+    [Symbol.asyncDispose]: stop,
   };
 }

package/src/test-utils/start-stub-source-daemon.ts

@@ -1,4 +1,5 @@
 import { join } from 'node:path';
+import { registerTestCleanup } from './register-test-cleanup';
 
 /**
  * Starts a daemon composed with a fixture source, in a process of its own
@@ -8,20 +9,21 @@ import { join } from 'node:path';
  * `ATC_TEST_SOURCES` picks its sources, the fixture one unless it holds
  * `none`; `ATC_TEST_FIXTURE_URL` holds the repository the fixture source
  * lists, and `ATC_TEST_SOURCE_LOG` a file it appends each listing to.
- * Disposal stops the process; hold the result with `await using`.
+ * The process stops once the current test finishes, so it must run inside
+ * a test; disposal stops it sooner, and a second stop does nothing.
  */
 export async function startStubSourceDaemon(env: Readonly<Record<string, string | undefined>>) {
-  const daemon = Bun.spawn([process.execPath, join(import.meta.dir, 'run-source-daemon.ts')], {
+  const daemon = Bun.spawn([process.execPath, join(import.meta.dir, 'run-stub-source-daemon.ts')], {
     env: { ATC_TEST_SOURCES: 'fixture', ...env },
     stdout: 'pipe',
     stderr: 'ignore',
   });
 
-  const stop = async () => {
+  const stop = registerTestCleanup(async () => {
     daemon.kill();
 
     await daemon.exited;
-  };
+  });
 
   const reader = daemon.stdout.getReader();
 

package/src/test-utils/start-stub-stalled-client.ts

@@ -0,0 +1,61 @@
+import { createConnection } from 'node:net';
+import { PROTOCOL_V, encodeMessage } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubStalledClient {
+  // Each chunk the client has read off its connection, in order.
+  readonly chunks: readonly unknown[];
+
+  // How many bytes have arrived on the connection and wait unread.
+  readonly countUnreadBytes: () => number;
+  readonly [Symbol.dispose]: () => void;
+}
+
+/**
+ * A stand-in for a daemon client that stops reading: it connects to the
+ * daemon's unix socket, sends a `daemon.hello` with no auth as `client`,
+ * reads the first chunk the daemon sends, and then holds its next read on
+ * a promise that never resolves, so whatever the daemon sends it after
+ * that backs up. Resolves once that first chunk arrives. The connection is
+ * destroyed once the current test finishes, so it must run inside a test;
+ * disposal destroys it sooner, and a second stop does nothing.
+ */
+export async function startStubStalledClient(
+  socketPath: string,
+  client: string,
+): Promise<StubStalledClient> {
+  const held = Promise.withResolvers<void>();
+  const first = Promise.withResolvers<void>();
+  const chunks: unknown[] = [];
+  const socket = createConnection(socketPath);
+
+  const stop = registerTestCleanup(() => {
+    socket.destroy();
+  });
+
+  socket.write(
+    encodeMessage({
+      v: PROTOCOL_V,
+      id: 1,
+      m: 'daemon.hello',
+      p: { client, auth: { scheme: 'none' } },
+    }),
+  );
+
+  void (async () => {
+    for await (const chunk of socket) {
+      chunks.push(chunk);
+      first.resolve();
+
+      await held.promise;
+    }
+  })();
+
+  await first.promise;
+
+  return {
+    chunks,
+    countUnreadBytes: () => socket.readableLength,
+    [Symbol.dispose]: stop,
+  };
+}

package/src/test-utils/start-stub-stalled-listener.ts

@@ -1,5 +1,6 @@
 import { createServer } from 'node:net';
 import type { Socket } from 'node:net';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubStalledListener {
   readonly [Symbol.dispose]: () => void;
@@ -9,8 +10,9 @@ interface StubStalledListener {
  * A stand-in for a peer that stops reading: it listens on the unix socket
  * path and accepts every connection but never reads from it, so what the
  * kernel does not buffer stays queued on the sender's side. Resolves once
- * it listens. Disposal destroys every connection it accepted and stops it;
- * hold the result with `using`.
+ * it listens. Once the current test finishes, it destroys every connection
+ * it accepted and stops, so it must run inside a test; disposal does so
+ * sooner, and a second stop does nothing.
  */
 export async function startStubStalledListener(path: string): Promise<StubStalledListener> {
   const peers = new Set<Socket>();
@@ -28,13 +30,15 @@ export async function startStubStalledListener(path: string): Promise<StubStalle
 
   await listening.promise;
 
-  return {
-    [Symbol.dispose]: () => {
-      for (const peer of peers) {
-        peer.destroy();
-      }
+  const stop = registerTestCleanup(() => {
+    for (const peer of peers) {
+      peer.destroy();
+    }
+
+    server.close();
+  });
 
-      server.close();
-    },
+  return {
+    [Symbol.dispose]: stop,
   };
 }

package/src/test-utils/start-stub-tcp-daemon.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PROTOCOL_V } from '../protocol/protocol';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubTCPDaemon {
   readonly port: number;
@@ -23,7 +24,9 @@ const REQUEST = z.object({ id: z.number(), m: z.string() });
  * newline-delimited protocol requests and answers each with an ok that holds
  * the request's method, recording every method in `seen`. It sends no
  * handshake of its own and checks no token. `reads` counts the reads it has
- * taken from every connection. Disposal stops it.
+ * taken from every connection. It stops once the current test finishes, so
+ * it must run inside a test; disposal stops it sooner, and a second stop
+ * does nothing.
  */
 export function startStubTCPDaemon(): StubTCPDaemon {
   const seen: string[] = [];
@@ -57,14 +60,16 @@ export function startStubTCPDaemon(): StubTCPDaemon {
     },
   });
 
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
   return {
     port: server.port,
     seen,
     get reads() {
       return reads;
     },
-    [Symbol.dispose]: () => {
-      server.stop(true);
-    },
+    [Symbol.dispose]: stop,
   };
 }

package/src/test-utils/start-stub-telemetry-collector.ts

@@ -1,9 +1,13 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 /**
  * A stand-in for better-auth's telemetry endpoint on a real HTTP port of the
  * loopback address. A process whose `BETTER_AUTH_TELEMETRY_ENDPOINT` holds
  * `url` sends its telemetry here. Every request is answered with HTTP 204,
- * and `received` holds the URL of each request, in order. Disposal stops the
- * server and resolves once it has stopped.
+ * and `received` holds the URL of each request, in order. The server stops
+ * once the current test finishes, so it must run inside a test; disposal
+ * stops it sooner and resolves once it has stopped, and a second stop does
+ * nothing.
  */
 export function startStubTelemetryCollector() {
   const received: string[] = [];
@@ -18,9 +22,11 @@ export function startStubTelemetryCollector() {
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${String(server.port)}/`,
     received,
-    [Symbol.asyncDispose]: () => server.stop(true),
+    [Symbol.asyncDispose]: stop,
   };
 }

package/src/test-utils/start-stub-unanswering-listener.ts

@@ -0,0 +1,41 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubUnansweringListener {
+  readonly port: number;
+
+  // What each read took from any connection, decoded, in arrival order.
+  readonly received: readonly string[];
+
+  readonly [Symbol.dispose]: () => void;
+}
+
+/**
+ * A stand-in for a daemon that accepts a connection and never answers it:
+ * on a loopback port, it records what each read takes from a connection,
+ * sends nothing back, and keeps the connection open. It stops, dropping
+ * every connection it holds, once the current test finishes, so it must run
+ * inside a test; disposal stops it sooner, and a second stop does nothing.
+ */
+export function startStubUnansweringListener(): StubUnansweringListener {
+  const received: string[] = [];
+
+  const server = Bun.listen({
+    hostname: '127.0.0.1',
+    port: 0,
+    socket: {
+      data(_socket, data) {
+        received.push(data.toString());
+      },
+    },
+  });
+
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
+  return {
+    port: server.port,
+    received,
+    [Symbol.dispose]: stop,
+  };
+}