@specific.dev/spectest 0.93.0 → 0.93.1

package/dist/components/email.js

@@ -1,22 +1,5 @@
-// `email()` — a real SMTP server as a spectest service. The app under test
-// points its SMTP transport at `<key>:1025` and sends mail exactly as it
-// would in production; every message is captured instead of delivered.
-// Tests read the mailbox through typed helpers on `ctx.svc.<key>`
-// (`lastEmail`, `emails`, `clear`), each recorded as an `email` event on
-// the test timeline — single-message ops embed the full captured message
-// (HTML body included) so the dashboard renders the actual email the test
-// asserted against, and returns come back inspect-wrapped so
-// `expect(mail.subject)` links under the step. To wait for a message to
-// *arrive*, use the standard `ctx.poll` with `lastEmail` as the predicate
-// (it returns `undefined` while the mailbox is empty); the winning
-// iteration's `email` event survives poll truncation, so the message still
-// renders nested under the wait step.
-//
-// Captured mail lives in the server's process memory, so it snapshots and
-// forks with the rest of the environment: a `dependsOn` child inherits the
-// parent's mailbox, sibling forks never see each other's messages — the
-// same isolation contract as fake state.
-import { pauseRecording, recordEmail, reserveEvent, resumeRecording, truncateUtf8, } from "../recorder.js";
+import { rawFetch } from "../harness/raw-fetch.js";
+import { recordEmail, reserveEvent, truncateUtf8, } from "../recorder.js";
 import { wrap } from "../inspect.js";
 const DEFAULT_IMAGE = "axllent/mailpit:v1.30";
 const SMTP_PORT = 1025;
@@ -140,29 +123,21 @@ async function instrumented(service, op, query, body) {
         throw err;
     }
 }
-/** Query the mail server's HTTP API. Recording is paused around the fetch
- *  so these internal polls don't land as `http` events on the timeline —
- *  the helper records one consolidated `email` event instead. */
+/** Internal HTTP stays native; the public helper records one email event. */
 async function api(base, path, init) {
-    pauseRecording();
+    const res = await rawFetch(`${base}${path}`, init);
+    if (!res.ok) {
+        throw new Error(`email server API ${path} failed: HTTP ${res.status}`);
+    }
+    const text = await res.text();
+    if (text === "")
+        return undefined;
     try {
-        const res = await fetch(`${base}${path}`, init);
-        if (!res.ok) {
-            throw new Error(`email server API ${path} failed: HTTP ${res.status}`);
-        }
-        const text = await res.text();
-        if (text === "")
-            return undefined;
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            // Mutating endpoints reply with a plain-text acknowledgement.
-            return text;
-        }
+        return JSON.parse(text);
     }
-    finally {
-        resumeRecording();
+    catch {
+        // Mutating endpoints reply with a plain-text acknowledgement.
+        return text;
     }
 }
 function addresses(v) {

package/dist/components/s3.js

@@ -1,3 +1,4 @@
+import { rawFetch } from "../harness/raw-fetch.js";
 import { S3Client } from "../s3.js";
 // Backing image, pinned internally (not user-configurable). adobe/s3mock 5.1.0
 // is the current release; avoid exactly 5.0.0, which crashed at startup on
@@ -75,7 +76,7 @@ export function s3(opts = {}) {
                         // CreateBucket is a plain `PUT` on the bucket root; the store
                         // returns 200 (or 409 if it already exists — idempotent enough to
                         // ignore).
-                        const res = await fetch(`http://${name}:${S3_PORT}/${bucket}`, {
+                        const res = await rawFetch(`http://${name}:${S3_PORT}/${bucket}`, {
                             method: "PUT",
                         });
                         if (!res.ok && res.status !== 409) {

package/dist/components/supabase.js

@@ -1,3 +1,4 @@
+import { rawFetch } from "../harness/raw-fetch.js";
 // A ready-to-use, self-hosted **Supabase** stack, expressed as a set of
 // spectest services (one container each) wired together on spectest-net.
 //
@@ -1807,7 +1808,7 @@ export function supabase(opts = {}) {
                     // snapshot and a test's diff is what its requests mutate.
                     setup: async () => {
                         const t0 = Date.now();
-                        const res = await fetch(`http://${g.key("functions")}:9000/_spectest/warm`);
+                        const res = await rawFetch(`http://${g.key("functions")}:9000/_spectest/warm`);
                         if (!res.ok) {
                             console.warn(`supabase(): edge functions warm-up answered ${res.status}; functions boot on first call instead.`);
                             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.93.0",
+  "version": "0.93.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/email.ts

@@ -1,3 +1,4 @@
+import { rawFetch } from "../harness/raw-fetch.js";
 // `email()` — a real SMTP server as a spectest service. The app under test
 // points its SMTP transport at `<key>:1025` and sends mail exactly as it
 // would in production; every message is captured instead of delivered.
@@ -19,10 +20,8 @@
 
 import type { ServiceDefinition } from "../index.js";
 import {
-  pauseRecording,
   recordEmail,
   reserveEvent,
-  resumeRecording,
   truncateUtf8,
   type EmailEventMessage,
   type EmailEventSummary,
@@ -262,26 +261,19 @@ async function instrumented<T>(
   }
 }
 
-/** Query the mail server's HTTP API. Recording is paused around the fetch
- *  so these internal polls don't land as `http` events on the timeline —
- *  the helper records one consolidated `email` event instead. */
+/** Internal HTTP stays native; the public helper records one email event. */
 async function api(base: string, path: string, init?: RequestInit): Promise<unknown> {
-  pauseRecording();
+  const res = await rawFetch(`${base}${path}`, init);
+  if (!res.ok) {
+    throw new Error(`email server API ${path} failed: HTTP ${res.status}`);
+  }
+  const text = await res.text();
+  if (text === "") return undefined;
   try {
-    const res = await fetch(`${base}${path}`, init);
-    if (!res.ok) {
-      throw new Error(`email server API ${path} failed: HTTP ${res.status}`);
-    }
-    const text = await res.text();
-    if (text === "") return undefined;
-    try {
-      return JSON.parse(text);
-    } catch {
-      // Mutating endpoints reply with a plain-text acknowledgement.
-      return text;
-    }
-  } finally {
-    resumeRecording();
+    return JSON.parse(text);
+  } catch {
+    // Mutating endpoints reply with a plain-text acknowledgement.
+    return text;
   }
 }
 

package/src/components/internal-fetch.test.ts

@@ -0,0 +1,109 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Exercise public component hooks with the same dispatcher and async scope as
+// bootstrap. A child process isolates global fetch and recorder state.
+async function check(code: string, workspace?: string): Promise<void> {
+  const moduleUrl = (file: string) => JSON.stringify(new URL(file, import.meta.url).href);
+  const script = `
+    import { strict as assert } from "node:assert";
+    import { s3 } from ${moduleUrl("./s3.ts")};
+    import { supabase } from ${moduleUrl("./supabase.ts")};
+    import { emailHelpers } from ${moduleUrl("./email.ts")};
+    import { installFetchWrapper } from ${moduleUrl("../harness/fetch.ts")};
+    import { createInstrumentationScope, runInstrumented } from ${moduleUrl("../harness/instrumentation-scope.ts")};
+    import { startRecording, stopRecording } from ${moduleUrl("../recorder.ts")};
+    let respond = () => Response.json({});
+    const requests = [];
+    globalThis.fetch = async (input, init) => {
+      requests.push({ url: String(input), method: init?.method ?? "GET" });
+      return respond();
+    };
+    const restore = installFetchWrapper();
+    const scope = createInstrumentationScope(false);
+    try {
+      await runInstrumented(scope, async () => {
+        assert.equal((await fetch("http://probe/")).status.unwrap(), 200);
+        requests.length = 0;
+        ${code}
+      });
+    } finally { scope.active = false; restore(); }
+  `;
+  const child = Bun.spawn([process.execPath, "--eval", script], {
+    env: { ...process.env, ...(workspace ? { SPECTEST_WORKSPACE: workspace } : {}) },
+    stdout: "pipe", stderr: "pipe",
+  });
+  const [exit, stdout, stderr] = await Promise.all([
+    child.exited, new Response(child.stdout).text(), new Response(child.stderr).text(),
+  ]);
+  expect(exit, stdout + stderr).toBe(0);
+}
+
+test.each([200, 201, 409, 403, 500])("S3 setup handles HTTP %i inside a wrapped setup scope", async (status) => {
+  await check(`
+    respond = () => new Response("bucket response", { status: ${status} });
+    const setup = s3({ buckets: ["uploads", "assets"] }).setup;
+    ${status === 403 || status === 500
+      ? `await assert.rejects(() => setup({ name: "storage" }), /failed to create bucket uploads: ${status}/);
+         assert.equal(requests.length, 1);`
+      : `await setup({ name: "storage" });
+         assert.deepEqual(requests, [
+           { url: "http://storage:9090/uploads", method: "PUT" },
+           { url: "http://storage:9090/assets", method: "PUT" },
+         ]);`}
+  `);
+});
+
+test("S3 setup propagates transport failures", async () => {
+  await check(`
+    respond = () => { throw new Error("connection refused"); };
+    await assert.rejects(() => s3({ buckets: ["uploads"] }).setup({ name: "storage" }), /connection refused/);
+  `);
+});
+
+test("Supabase warm-up handles errors and reads native JSON in a wrapped setup scope", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-component-fetch-"));
+  try {
+    await mkdir(join(root, "supabase/functions/hello"), { recursive: true });
+    await writeFile(join(root, "supabase/functions/hello/index.ts"), "export default {};");
+    await check(`
+      const parts = supabase({ dir: "supabase" }).group.services({
+        name: "supabase", key: part => part === "gateway" ? "supabase" : "supabase-" + part,
+      });
+      const warnings = [], logs = [];
+      console.warn = (...args) => warnings.push(args.join(" "));
+      console.log = (...args) => logs.push(args.join(" "));
+      respond = () => new Response("unavailable", { status: 503 });
+      await parts.functions.setup();
+      assert.equal(warnings.length, 1);
+      assert.match(warnings[0], /warm-up answered 503/);
+      respond = () => Response.json({ mode: "shared", warmed: ["hello"], failed: {} });
+      await parts.functions.setup();
+      assert.equal(logs.length, 1);
+      assert.match(logs[0], /warmed 1 edge function in one isolate/);
+    `, root);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("email helpers reject HTTP errors and retain their public event without internal HTTP events", async () => {
+  await check(`
+    const mail = emailHelpers("mail");
+    scope.recording = true;
+    startRecording();
+    respond = () => new Response("unavailable", { status: 503 });
+    await assert.rejects(() => mail.clear(), /email server API .* failed: HTTP 503/);
+    let events = stopRecording();
+    assert.deepEqual(events.map(e => e.kind), ["email"]);
+    assert.match(events[0].error, /HTTP 503/);
+    startRecording();
+    respond = () => Response.json({ messages: [] });
+    assert.deepEqual((await mail.emails()).unwrap(), []);
+    respond = () => new Response(null, { status: 204 });
+    await mail.clear();
+    events = stopRecording();
+    assert.deepEqual(events.map(e => e.kind), ["email", "email"]);
+    assert.equal(events.some(e => e.error), false);
+  `);
+});

package/src/components/s3.ts

@@ -1,3 +1,4 @@
+import { rawFetch } from "../harness/raw-fetch.js";
 import type { ServiceDefinition } from "../index.js";
 import { S3Client, type S3ClientLike } from "../s3.js";
 
@@ -123,7 +124,7 @@ export function s3(opts: S3Options = {}) {
               // CreateBucket is a plain `PUT` on the bucket root; the store
               // returns 200 (or 409 if it already exists — idempotent enough to
               // ignore).
-              const res = await fetch(`http://${name}:${S3_PORT}/${bucket}`, {
+              const res = await rawFetch(`http://${name}:${S3_PORT}/${bucket}`, {
                 method: "PUT",
               });
               if (!res.ok && res.status !== 409) {

package/src/components/supabase.ts

@@ -1,3 +1,4 @@
+import { rawFetch } from "../harness/raw-fetch.js";
 // A ready-to-use, self-hosted **Supabase** stack, expressed as a set of
 // spectest services (one container each) wired together on spectest-net.
 //
@@ -2300,7 +2301,7 @@ export function supabase(opts: SupabaseOptions = {}): SupabaseStack {
           // snapshot and a test's diff is what its requests mutate.
           setup: async () => {
             const t0 = Date.now();
-            const res = await fetch(`http://${g.key("functions")}:9000/_spectest/warm`);
+            const res = await rawFetch(`http://${g.key("functions")}:9000/_spectest/warm`);
             if (!res.ok) {
               console.warn(`supabase(): edge functions warm-up answered ${res.status}; functions boot on first call instead.`);
               return;