siltrun 0.1.0

package/src/deploy.test.ts

@@ -0,0 +1,330 @@
+import { test, expect, describe } from "bun:test";
+import { join } from "node:path";
+import { parseDeployArgs, runDeploy, DEFAULT_INTAKE_URL, type DeployLogger } from "./deploy.ts";
+import { bundleContract } from "./bundle.ts";
+import { ArgError } from "./args.ts";
+import type { DeployStatus } from "./deploy-client.ts";
+
+// A real example contract — bundled with the REAL bundler so raw-body assertions are against
+// genuine bundled JS, not a synthetic string.
+const HELLO_ROOM = join(import.meta.dir, "..", "..", "..", "examples", "hello-room", "room.ts");
+
+// ── capturing logger ────────────────────────────────────────────────────────
+function capLogger(): { logger: DeployLogger; lines: string[]; text: () => string } {
+  const lines: string[] = [];
+  const push = (m?: string) => {
+    lines.push(m ?? "");
+  };
+  return {
+    logger: { info: push, warn: push, error: push, plain: push },
+    lines,
+    text: () => lines.join("\n"),
+  };
+}
+
+// ── a mock intake worker that plays the v0 contract ─────────────────────────
+interface MockOpts {
+  failWith?: string; // if set, GET reports failed with this error
+  stayProvisioning?: boolean; // if set, GET never reaches live (for the timeout path)
+}
+function makeMockIntake(opts: MockOpts = {}) {
+  const received = {
+    posts: 0,
+    gets: 0,
+    room: undefined as string | undefined,
+    body: undefined as string | undefined,
+    contentType: undefined as string | undefined,
+    auth: undefined as string | undefined,
+  };
+  let getCount = 0;
+  const server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (req.method === "POST" && url.pathname === "/v0/deploy") {
+        received.posts++;
+        received.room = url.searchParams.get("room") ?? undefined;
+        received.body = await req.text();
+        received.contentType = req.headers.get("content-type") ?? undefined;
+        received.auth = req.headers.get("authorization") ?? undefined;
+        return Response.json(
+          { deployId: "dep_test_1", room: received.room, status: "queued" as DeployStatus },
+          { status: 201 },
+        );
+      }
+      if (req.method === "GET" && url.pathname.startsWith("/v0/deploy/")) {
+        received.gets++;
+        getCount++;
+        if (opts.failWith) {
+          return Response.json({
+            deployId: "dep_test_1",
+            room: received.room,
+            status: "failed" as DeployStatus,
+            error: opts.failWith,
+          });
+        }
+        if (!opts.stayProvisioning && getCount >= 2) {
+          return Response.json({
+            deployId: "dep_test_1",
+            room: received.room,
+            status: "live" as DeployStatus,
+            url: `https://relay.silt.digitalpine.io:4440/room/${received.room}`,
+            doctorVerdict: "SILT-DOCTOR: GREEN (300-tick replay deterministic)",
+          });
+        }
+        return Response.json({
+          deployId: "dep_test_1",
+          room: received.room,
+          status: "provisioning" as DeployStatus,
+        });
+      }
+      return new Response("not found", { status: 404 });
+    },
+  });
+  return { server, url: `http://localhost:${server.port}`, received, stop: () => server.stop(true) };
+}
+
+const noSleep = () => Promise.resolve();
+
+// ── arg parsing ─────────────────────────────────────────────────────────────
+describe("parseDeployArgs", () => {
+  test("requires a contract positional", () => {
+    expect(() => parseDeployArgs([], {})).toThrow(ArgError);
+  });
+  test("derives the room from the contract path (same rule as dev)", () => {
+    expect(parseDeployArgs(["examples/hello-room/room.ts"], {}).room).toBe("hello-room");
+  });
+  test("--room flag wins and is validated", () => {
+    expect(parseDeployArgs(["room.ts", "--room", "my-arena"], {}).room).toBe("my-arena");
+    expect(() => parseDeployArgs(["room.ts", "--room", "bad name"], {})).toThrow(ArgError);
+  });
+  test("deployed room names are capped at 12 chars (tap<room> / IFNAMSIZ, DIG-676)", () => {
+    // 12 exactly is fine; 13 is rejected with the honest reason, client-side.
+    expect(parseDeployArgs(["room.ts", "--room", "abcdefghijkl"], {}).room).toBe("abcdefghijkl");
+    expect(() => parseDeployArgs(["room.ts", "--room", "abcdefghijklm"], {})).toThrow(
+      /12|interface/,
+    );
+    // A DERIVED name over the cap is caught too, with the --room way out.
+    expect(() => parseDeployArgs(["examples/my-very-long-game-name/room.ts"], {})).toThrow(
+      /--room/,
+    );
+    // Local dev is deliberately uncapped — this rule is deploy-only.
+  });
+  test("SILT_ROOM env applies when no flag", () => {
+    expect(parseDeployArgs(["room.ts"], { SILT_ROOM: "env-room" }).room).toBe("env-room");
+  });
+  test("baked default intake URL is a concrete https worker URL (filled at integration)", () => {
+    expect(DEFAULT_INTAKE_URL).toMatch(/^https:\/\//);
+    expect(DEFAULT_INTAKE_URL).not.toContain("PLACEHOLDER");
+  });
+});
+
+// ── the gate + upload + poll happy path ─────────────────────────────────────
+describe("runDeploy — happy path", () => {
+  test("bundle+doctor gate runs, POSTs RAW bundle, polls, prints the live URL", async () => {
+    const mock = makeMockIntake();
+    const cap = capLogger();
+
+    // Real bundler (proves reuse), captured so we can byte-compare the uploaded body.
+    let capturedBundlePath = "";
+    let bundleCalls = 0;
+    const bundle = async (contract: string, out: string) => {
+      bundleCalls++;
+      const p = await bundleContract(contract, out);
+      capturedBundlePath = out;
+      return p;
+    };
+    // Doctor injected GREEN + spied so we can assert the gate ran (and ran before any HTTP).
+    let doctorCalledAt = -1;
+    const doctor = async () => {
+      doctorCalledAt = mock.received.posts; // must be 0 — no POST yet when the doctor runs
+      return { status: "ok" as const, note: "300-tick replay matched" };
+    };
+
+    const result = await runDeploy(
+      { contract: HELLO_ROOM, room: "hello-room" },
+      {
+        env: { SILT_DEPLOY_TOKEN: "tester-token", SILT_DEPLOY_URL: mock.url },
+        fetchImpl: fetch,
+        sleep: noSleep,
+        bundle,
+        doctor,
+        logger: cap.logger,
+      },
+    );
+
+    // gate ran, and ran BEFORE any upload
+    expect(bundleCalls).toBe(1);
+    expect(doctorCalledAt).toBe(0);
+
+    // POSTed exactly once, to the right room, with Bearer + text/javascript
+    expect(mock.received.posts).toBe(1);
+    expect(mock.received.room).toBe("hello-room");
+    expect(mock.received.auth).toBe("Bearer tester-token");
+    expect(mock.received.contentType).toBe("text/javascript");
+
+    // RAW body: byte-identical to the bundle file, NOT base64
+    const bundleText = await Bun.file(capturedBundlePath).text();
+    expect(mock.received.body).toBe(bundleText);
+    expect(mock.received.body).not.toBe(btoa(bundleText));
+    expect(mock.received.body).toContain("clamp"); // a real source identifier survives bundling
+
+    // polled to live and surfaced the URL
+    expect(mock.received.gets).toBeGreaterThanOrEqual(2);
+    expect(result.ok).toBe(true);
+    expect(result.status).toBe("live");
+    expect(result.url).toBe("https://relay.silt.digitalpine.io:4440/room/hello-room");
+    expect(cap.text()).toContain("https://relay.silt.digitalpine.io:4440/room/hello-room");
+
+    // the tester never constructs a URL: the check/play URL is printed with the room
+    // pre-filled and CORRECTLY URL-ENCODED (CONTROL-PLANE v0.2 §C).
+    const roomUrl = "https://relay.silt.digitalpine.io:4440/room/hello-room";
+    const expectedCheckUrl = `${mock.url}/check?room=${encodeURIComponent(roomUrl)}`;
+    expect(cap.text()).toContain(expectedCheckUrl);
+    // the room segment must be percent-encoded (":" -> "%3A", "/" -> "%2F"), never raw in the query
+    expect(cap.text()).toContain("/check?room=https%3A%2F%2Frelay.silt.digitalpine.io%3A4440%2Froom%2Fhello-room");
+
+    // the server-side determinism verdict is surfaced to the tester (CONTROL-PLANE v0.2 §B)
+    expect(cap.text()).toContain("SILT-DOCTOR: GREEN (300-tick replay deterministic)");
+    expect(cap.text()).toContain("determinism verified server-side");
+
+    mock.stop();
+  });
+});
+
+// ── drift aborts before ANY http ────────────────────────────────────────────
+describe("runDeploy — determinism drift", () => {
+  test("a drifting contract aborts BEFORE any HTTP call", async () => {
+    const cap = capLogger();
+    let fetchCalls = 0;
+    const spyFetch = ((..._args: Parameters<typeof fetch>) => {
+      fetchCalls++;
+      return Promise.reject(new Error("network must not be touched on drift"));
+    }) as typeof fetch;
+
+    let bundleCalled = false;
+    const bundle = async (_c: string, out: string) => {
+      bundleCalled = true;
+      await Bun.write(out, "export default { tick(s){return s} }");
+      return out;
+    };
+    const doctor = async () => ({
+      status: "drift" as const,
+      note: "determinism drift detected",
+      output: "✗ FIRST DRIFT at tick 42 — field ships.x",
+    });
+
+    const result = await runDeploy(
+      { contract: HELLO_ROOM, room: "hello-room" },
+      {
+        env: { SILT_DEPLOY_TOKEN: "tester-token", SILT_DEPLOY_URL: "http://127.0.0.1:1/unused" },
+        fetchImpl: spyFetch,
+        sleep: noSleep,
+        bundle,
+        doctor,
+        logger: cap.logger,
+      },
+    );
+
+    expect(bundleCalled).toBe(true); // gate ran
+    expect(fetchCalls).toBe(0); // …then aborted before any upload
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe("aborted");
+    expect(cap.text()).toContain("drift");
+  });
+});
+
+// ── missing token → friendly error, no http ─────────────────────────────────
+describe("runDeploy — missing token", () => {
+  test("no SILT_DEPLOY_TOKEN → friendly error, no HTTP, no bundle", async () => {
+    const cap = capLogger();
+    let fetchCalls = 0;
+    const spyFetch = (() => {
+      fetchCalls++;
+      return Promise.reject(new Error("should not fetch without a token"));
+    }) as unknown as typeof fetch;
+    let bundleCalled = false;
+    const bundle = async (_c: string, out: string) => {
+      bundleCalled = true;
+      return out;
+    };
+
+    const result = await runDeploy(
+      { contract: HELLO_ROOM, room: "hello-room" },
+      {
+        env: {}, // no token
+        fetchImpl: spyFetch,
+        sleep: noSleep,
+        bundle,
+        doctor: async () => ({ status: "ok" as const, note: "n/a" }),
+        logger: cap.logger,
+      },
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe("aborted");
+    expect(fetchCalls).toBe(0);
+    expect(bundleCalled).toBe(false);
+    expect(cap.text()).toContain("SILT_DEPLOY_TOKEN");
+  });
+});
+
+// ── server-reported failure surfaces honestly ───────────────────────────────
+describe("runDeploy — server failure", () => {
+  test("server 'failed' status surfaces the server error, no false success", async () => {
+    const mock = makeMockIntake({ failWith: "beta at capacity — no free ports in 4440-4449" });
+    const cap = capLogger();
+
+    const result = await runDeploy(
+      { contract: HELLO_ROOM, room: "hello-room" },
+      {
+        env: { SILT_DEPLOY_TOKEN: "tester-token", SILT_DEPLOY_URL: mock.url },
+        fetchImpl: fetch,
+        sleep: noSleep,
+        bundle: bundleContract,
+        doctor: async () => ({ status: "ok" as const, note: "ok" }),
+        logger: cap.logger,
+      },
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("beta at capacity");
+    expect(cap.text()).toContain("beta at capacity");
+    // Vercel bar: operator-only reasons must still leave the tester a route —
+    // reference id + support channel, on every server failure.
+    expect(cap.text()).toContain("dep_test_1");
+    expect(cap.text()).toContain("#support");
+    mock.stop();
+  });
+});
+
+// ── honest timeout ──────────────────────────────────────────────────────────
+describe("runDeploy — timeout", () => {
+  test("never-live deploy times out honestly (no false success)", async () => {
+    const mock = makeMockIntake({ stayProvisioning: true });
+    const cap = capLogger();
+
+    const result = await runDeploy(
+      { contract: HELLO_ROOM, room: "hello-room" },
+      {
+        env: { SILT_DEPLOY_TOKEN: "tester-token", SILT_DEPLOY_URL: mock.url },
+        fetchImpl: fetch,
+        sleep: noSleep,
+        bundle: bundleContract,
+        doctor: async () => ({ status: "ok" as const, note: "ok" }),
+        logger: cap.logger,
+        pollIntervalMs: 1,
+        pollBudgetMs: 8, // tiny budget + noop sleep → a couple polls then honest timeout
+      },
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe("timeout");
+    expect(cap.text().toLowerCase()).toContain("stopped watching");
+    // Vercel bar: the tester leaves with a reference + a place to report.
+    expect(cap.text()).toContain("dep_test_1");
+    expect(cap.text()).toContain("#support");
+    mock.stop();
+  });
+});