import { decodeFirst } from "@atcute/cbor"; import { runDurableObjectAlarm, runInDurableObject } from "cloudflare:test"; import { env, exports } from "cloudflare:workers"; import { afterEach, describe, expect, it, vi } from "vitest"; import { cleanLine, controlFrame, dataFrame, frameLine, logLines } from "../src/logs"; import { limitKey } from "../src/xrpc"; import type { Logs } from "../src/logs"; import { seed, signature, repoDid as repo } from "./helpers"; const host = "treadle.example.com"; const buildUrl = "https://api.buildkite.com/v2/organizations/gpanders/pipelines/treadle/builds/7"; const cap = 2 * 1024 * 1024; const marker = "[treadle: log longer than 2 MiB]\n"; const t0 = 1793959202000; const startedAt = "2026-11-06T10:00:00.000Z"; const finishedAt = "2026-11-06T10:01:00.000Z"; function bk(ms: number): string { return `\u001b_bk;t=${ms}\u0007`; } describe("frameLine", () => { it("reads the step, time and text of each frame", () => { const step = { step: 2, name: "Test", command: "make" }; expect( [ controlFrame("ci.yml", step, "start", startedAt), dataFrame("ci.yml", 2, `${"é".repeat(300)}\n`, startedAt), dataFrame("ci.yml", 2, `${"x".repeat(70_000)}\n`, startedAt), controlFrame("ci.yml", step, "end", finishedAt, "failed"), ].map(frameLine), ).toEqual([ { step: 2, time: startedAt, text: "--- step 2: Test" }, { step: 2, time: startedAt, text: "é".repeat(300) }, { step: 2, time: startedAt, text: "x".repeat(70_000) }, { step: 2, time: finishedAt, text: "--- step 2: Test (failed)" }, ]); }); }); describe("cleanLine", () => { const time = new Date(t0).toISOString(); it.each([ ["plain text", "plain", "plain", undefined], ["a timestamp", `${bk(t0)}hello`, "hello", time], ["timestamps inside the line", `${bk(t0)}a\u001b[K${bk(t0 + 1000)}b`, "a\u001b[Kb", time], ["a trailing carriage return", "crlf\r", "crlf", undefined], ["progress output", `${bk(t0)}10%\r50%\r100%\r`, "100%", time], ["colours", "\u001b[31mred\u001b[0m", "\u001b[31mred\u001b[0m", undefined], ])("reads %s", (_, line, text, expected) => { expect(cleanLine(line)).toEqual({ text, time: expected }); }); }); describe("logLines", () => { const bytes = new TextEncoder().encode("one\ntwo\r\nthr"); it("keeps a partial last line for later", () => { expect(logLines(bytes, false)).toEqual({ lines: [{ text: "one" }, { text: "two" }], used: 9, }); }); it("reads the partial last line of a finished log", () => { expect(logLines(bytes, true)).toEqual({ lines: [{ text: "one" }, { text: "two" }, { text: "thr" }], used: 12, }); }); it("counts bytes, not characters", () => { expect(logLines(new TextEncoder().encode("é\nx"), false)).toEqual({ lines: [{ text: "é" }], used: 3, }); }); }); describe("limitKey", () => { it.each([ ["203.0.113.7", "203.0.113.7"], ["2001:db8:1:2:3:4:5:6", "2001:db8:1:2"], ["2001:db8::5", "2001:db8:0:0"], ["2001:db8:1:2::", "2001:db8:1:2"], ["::1", "0:0:0:0"], ])("keys %s by %s", (ip, key) => { expect(limitKey(ip)).toBe(key); }); }); interface Viewer { ws: WebSocket; headers: unknown[]; bodies: unknown[]; closed: Promise; code: number | undefined; } let pipelineCount = 0; let rkey = ""; let build: { id: string; number: number; state: string; jobs: object[] }; let logs: Record; let requests: Request[] = []; let gate: Promise | undefined; let failingLog: string | undefined; let wholeLogs = false; let logCanceled = false; afterEach(async () => { await runInDurableObject(logsStub(), (_instance, state) => state.storage.deleteAll()); }); function logsStub(): DurableObjectStub { return exports.Logs.getByName(`${rkey}/ci.yml`); } function query(): string { return `repo=${repo}&pipeline=${rkey}&workflows=ci.yml`; } async function setup(status: string, buildNumber: number | null = 7): Promise { pipelineCount++; rkey = `3logs${pipelineCount}`; await runInDurableObject(exports.Store.getByName("main"), async (_instance, state) => { await state.storage.deleteAlarm(); seed(state.storage, [ { rkey, repo, trigger: { $type: "org.tangled.event.push" }, commit: "a".repeat(40), createdAt: new Date().toISOString(), runs: [ { workflow: "ci.yml", status, buildUuid: "uuid-1", ...(buildNumber === null ? {} : { buildNumber }), }, ], }, ]); }); } function job(id: string, state: string, fields: object = {}): object { const finished = ["passed", "failed", "canceled"].includes(state); return { id, type: "script", name: `job ${id}`, command: "make", state, started_at: state === "scheduled" ? null : startedAt, finished_at: finished ? finishedAt : null, retried: false, ...fields, }; } function mockBuildkite( headers: Record = {}, buildStatus = 200, contentRange = true, ): void { requests = []; gate = undefined; failingLog = undefined; wholeLogs = false; logCanceled = false; vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => { const request = new Request(input, init); requests.push(request); if (request.url === buildUrl) { return Response.json(build, { status: buildStatus, headers }); } await gate; const id = /\/jobs\/([^/]+)\/log$/.exec(request.url)?.[1] ?? ""; if (id === failingLog) { return new Response("bad gateway", { status: 502 }); } const log = logs[id]; if (log === undefined) { return new Response("not found", { status: 404 }); } const bytes = new TextEncoder().encode(log); if (wholeLogs) { return new Response( new ReadableStream( { pull(controller) { controller.enqueue(bytes); controller.close(); }, cancel() { logCanceled = true; }, }, { highWaterMark: 0 }, ), ); } if (bytes.length === 0) { return new Response(null, { status: 416 }); } const n = Number(/^bytes=-(\d+)$/.exec(request.headers.get("range") ?? "")?.[1]); const start = Math.max(0, bytes.length - n); return new Response(bytes.slice(start), { status: 206, headers: { ...(contentRange ? { "Content-Range": `bytes ${start}-${bytes.length - 1}/${bytes.length}` } : {}), ...headers, }, }); }); } function logRequests(): Request[] { return requests.filter((request) => request.url.endsWith("/log")); } function subscribe(params: string, init?: RequestInit): Promise { return exports.default.fetch( `https://${host}/xrpc/org.tangled.ci.subscribePipelineLogs?${params}`, init ?? { headers: { Upgrade: "websocket" } }, ); } async function connect(): Promise { const response = await subscribe(query()); expect(response.status).toBe(101); const ws = response.webSocket; if (ws === null) { throw new Error("no WebSocket"); } ws.binaryType = "arraybuffer"; ws.accept(); const viewer: Viewer = { ws, headers: [], bodies: [], closed: new Promise((resolve) => { ws.addEventListener("close", (event) => { viewer.code = event.code; resolve(event.code); }); }), code: undefined, }; ws.addEventListener("message", (event) => { if (!(event.data instanceof ArrayBuffer)) { return; } const header: [unknown, Uint8Array] = decodeFirst(new Uint8Array(event.data)); const body: [unknown, Uint8Array] = decodeFirst(header[1]); viewer.headers.push(header[0]); viewer.bodies.push(body[0]); }); return viewer; } async function deliver(event: string, payload: object): Promise { const body = JSON.stringify(payload); const ts = Math.floor(Date.now() / 1000); const response = await exports.default.fetch(`https://${host}/webhooks/buildkite`, { method: "POST", headers: { "Content-Type": "application/json", "X-Buildkite-Event": event, "X-Buildkite-Signature": await signature(body, ts, env.BUILDKITE_WEBHOOK_SECRET ?? ""), }, body, }); expect(response.status).toBe(200); } function webhookBuild(state: string, number = 7): object { return { id: "uuid-1", number, state, commit: "a".repeat(40), meta_data: { "treadle:pipeline": rkey, "treadle:workflow": "ci.yml" }, }; } // Runs the alarm as if the poll interval has passed. async function tick(): Promise { await runInDurableObject(logsStub(), (_instance, state) => { state.storage.kv.delete("polledAt"); }); return await runDurableObjectAlarm(logsStub()); } function alarmTime(): Promise { return runInDurableObject(logsStub(), (_instance, state) => state.storage.getAlarm()); } function control(step: number, status: "start" | "end", fields: object = {}): object { return { time: status === "start" ? startedAt : finishedAt, workflow: "ci.yml", step, content: `job ${["a", "b", "c"][step]}`, command: "make", status, kind: "user", ...fields, }; } function data(step: number, content: string, time: unknown = expect.any(String)): object { return { time, workflow: "ci.yml", step, content, stream: "stdout" }; } describe("subscribePipelineLogs", () => { it.each<[string, () => string, number, string]>([ [ "a repo that is not a DID", () => `repo=x&pipeline=${rkey}&workflows=ci.yml`, 400, "InvalidRequest", ], ["no pipeline", () => `repo=${repo}&workflows=ci.yml`, 400, "InvalidRequest"], ["no workflow", () => `repo=${repo}&pipeline=${rkey}`, 400, "InvalidRequest"], ["two workflows", () => `${query()}&workflows=b.yml`, 400, "InvalidRequest"], [ "an unknown pipeline", () => `repo=${repo}&pipeline=3nope&workflows=ci.yml`, 404, "PipelineNotFound", ], [ "a pipeline of another repo", () => `repo=did:plc:other&pipeline=${rkey}&workflows=ci.yml`, 404, "PipelineNotFound", ], [ "an unknown workflow", () => `repo=${repo}&pipeline=${rkey}&workflows=b.yml`, 404, "WorkflowNotFound", ], ])("refuses %s before the upgrade", async (_, params, status, error) => { await setup("running"); const response = await subscribe(params()); expect(response.status).toBe(status); expect(response.headers.get("access-control-allow-origin")).toBe("*"); expect(await response.json()).toMatchObject({ error }); }); it("refuses a request without a WebSocket upgrade", async () => { await setup("running"); const response = await subscribe(query(), {}); expect(response.status).toBe(400); expect(await response.json()).toMatchObject({ error: "InvalidRequest" }); }); it("limits each client IP to 20 requests a minute", async () => { const init = { headers: { "CF-Connecting-IP": "203.0.113.7" } }; const allowed = await Promise.all( Array.from({ length: 20 }, () => subscribe(query(), init)), ); expect(allowed.map((response) => response.status)).toEqual(Array(20).fill(400)); const response = await subscribe(query(), init); expect(response.status).toBe(429); expect(await response.json()).toMatchObject({ error: "RateLimitExceeded" }); const other = { headers: { "CF-Connecting-IP": "203.0.113.8" } }; expect((await subscribe(query(), other)).status).toBe(400); }); it("streams an engine: cloudflare run from its Runner", async () => { await setup("success", null); const name = `${repo}/main/ci.yml`; await runInDurableObject(exports.Store.getByName("main"), (_instance, state) => { state.storage.sql.exec( "UPDATE workflow_runs SET engine = 'cloudflare', runner = ? WHERE pipeline = ?", name, rkey, ); }); const step = { step: 1, name: "test", command: "make" }; await runInDurableObject(exports.Runner.getByName(name), (_instance, state) => { for (const [pipeline, frame] of [ [rkey, controlFrame("ci.yml", step, "start", startedAt)], ["3other", dataFrame("ci.yml", 1, "other\n", startedAt)], [rkey, dataFrame("ci.yml", 1, "hi\n", startedAt)], ] as const) { state.storage.sql.exec( "INSERT INTO frames (pipeline, frame) VALUES (?, ?)", pipeline, frame, ); } }); const viewer = await connect(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([ control(1, "start", { content: "test", time: startedAt }), data(1, "hi\n", startedAt), ]); expect(requests).toEqual([]); }); it("streams the frames that a Runner sends after the viewer connects", async () => { await setup("running", null); const name = `${repo}/main/ci.yml`; await runInDurableObject(exports.Store.getByName("main"), (_instance, state) => { state.storage.sql.exec( "UPDATE workflow_runs SET engine = 'cloudflare', runner = ? WHERE pipeline = ?", name, rkey, ); }); const viewer = await connect(); const runner = exports.Runner.getByName(name); const now = new Date().toISOString(); await runInDurableObject(runner, async (_instance, state) => { const run = { pipeline: rkey, workflow: "ci.yml", phase: "done", finishedAt: now }; state.storage.kv.put(`run/${rkey}`, { ...run, status: "success" }); state.storage.kv.put("current", rkey); state.storage.kv.put("snapshotStep", 2); state.storage.kv.put("reported", `${rkey} success `); await state.storage.setAlarm(Date.now()); }); await runDurableObjectAlarm(runner); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toMatchObject([ { step: 2, content: "treadle: no snapshot: the Runner restarted\n" }, { step: 2, status: "end", outcome: "success" }, ]); }); it("closes the log of an engine: cloudflare run that never reached a Runner", async () => { await setup("cancelled", null); await runInDurableObject(exports.Store.getByName("main"), (_instance, state) => { state.storage.sql.exec("UPDATE workflow_runs SET engine = 'cloudflare'"); }); const viewer = await connect(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([]); }); it("replays a finished run and closes", async () => { await setup("failed"); build = { id: "uuid-1", number: 7, state: "failed", jobs: [ job("a", "passed"), { id: "w", type: "waiter" }, job("b", "failed", { name: null, command: "make lint", retried: true }), job("c", "failed"), job("d", "scheduled"), ], }; logs = { a: `${bk(t0)}hello\r\nworld\n`, b: "x", c: "" }; mockBuildkite(); const viewer = await connect(); expect(await viewer.closed).toBe(1000); expect(viewer.headers[0]).toEqual({ op: 1, t: "#control" }); expect(viewer.headers[1]).toEqual({ op: 1, t: "#data" }); const time = new Date(t0).toISOString(); expect(viewer.bodies).toEqual([ control(0, "start"), data(0, "hello\n", time), data(0, "world\n", time), control(0, "end", { outcome: "success" }), control(1, "start", { content: "make lint", command: "make lint" }), data(1, "x\n"), control(1, "end", { content: "make lint", command: "make lint" }), control(2, "start"), control(2, "end", { outcome: "failed" }), ]); expect(logRequests().map((request) => request.headers.get("range"))).toEqual([ `bytes=-${cap}`, `bytes=-${cap}`, `bytes=-${cap}`, ]); expect(logRequests()[0]?.headers.get("accept")).toBe("text/plain"); expect(logRequests()[0]?.headers.get("authorization")).toBe("Bearer test-token"); }); it("replays the last 2 MiB of a long log after a marker", async () => { await setup("success"); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed")] }; logs = { a: `early line\n${"z".repeat(cap - 5)}\nlast\n` }; mockBuildkite(); const viewer = await connect(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([ control(0, "start"), data(0, marker), data(0, "last\n"), control(0, "end", { outcome: "success" }), ]); }); it("closes a viewer of a run that never got a build", async () => { await setup("failed", null); mockBuildkite(); const viewer = await connect(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([]); expect(requests).toHaveLength(0); }); it("retries a failed replay on the next alarm", async () => { await setup("success"); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed")] }; logs = { a: "one\n" }; mockBuildkite({}, 502); const viewer = await connect(); await vi.waitFor(async () => { expect(requests).toHaveLength(1); expect(await alarmTime()).not.toBeNull(); }); expect(viewer.code).toBeUndefined(); mockBuildkite(); await tick(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([ control(0, "start"), data(0, "one\n"), control(0, "end", { outcome: "success" }), ]); }); it("waits for the rate limit window before a replay", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const first = await connect(); await vi.waitFor(() => { expect(first.bodies).toHaveLength(2); }); logs = { a: "one\ntwo\n" }; mockBuildkite({ "RateLimit-User-Remaining": "3", "RateLimit-User-Reset": "30" }); await tick(); expect(logRequests()).toHaveLength(1); const second = await connect(); await tick(); expect(logRequests()).toHaveLength(1); expect(second.bodies).toEqual([]); }); it("sends a replay once after a partial failure", async () => { await setup("success"); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed"), job("b", "passed")], }; logs = { a: "one\n", b: "two\n" }; mockBuildkite(); failingLog = "b"; const viewer = await connect(); await vi.waitFor(async () => { expect(logRequests()).toHaveLength(2); expect(await alarmTime()).not.toBeNull(); }); failingLog = undefined; await tick(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toEqual([ control(0, "start"), data(0, "one\n"), control(0, "end", { outcome: "success" }), control(1, "start"), data(1, "two\n"), control(1, "end", { outcome: "success" }), ]); }); it("closes with an error when Buildkite rejects the replay", async () => { await setup("success"); mockBuildkite({}, 404); const viewer = await connect(); expect(await viewer.closed).toBe(1011); expect(viewer.headers).toEqual([{ op: -1 }]); expect(viewer.bodies).toEqual([{ error: "UpstreamUnavailable" }]); }); it("closes with an error when a log has no usable range", async () => { await setup("success"); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed")] }; logs = { a: "one\n" }; mockBuildkite({}, 200, false); const viewer = await connect(); expect(await viewer.closed).toBe(1011); }); it("does not read a whole log without a length", async () => { await setup("success"); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed")] }; logs = { a: "one\n" }; mockBuildkite(); wholeLogs = true; const viewer = await connect(); expect(await viewer.closed).toBe(1011); expect(logCanceled).toBe(true); }); it("keeps streaming when the check after a finish event fails", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toHaveLength(2); }); mockBuildkite({}, 502); const failed = await logsStub() .update(7, "success", null) .then( () => false, () => true, ); expect(failed).toBe(true); build = { id: "uuid-1", number: 7, state: "passed", jobs: [job("a", "passed")] }; logs = { a: "one\ntwo\n" }; mockBuildkite(); await tick(); expect(await viewer.closed).toBe(1000); expect(viewer.bodies.slice(2)).toEqual([ data(0, "two\n"), control(0, "end", { outcome: "success" }), ]); }); it.each(["running", "cancelled"])( "keeps a canceling build live when the Store says %s", async (status) => { await setup(status); build = { id: "uuid-1", number: 7, state: "canceling", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toEqual([control(0, "start"), data(0, "one\n")]); }); expect(viewer.code).toBeUndefined(); expect(await alarmTime()).not.toBeNull(); }, ); it("keeps a canceling build live until its jobs finish", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "canceling", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toEqual([control(0, "start"), data(0, "one\n")]); }); expect(viewer.code).toBeUndefined(); expect(await alarmTime()).not.toBeNull(); }); it("ignores a partial log response without a Content-Range", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite({}, 200, false); const viewer = await connect(); await vi.waitFor(() => { expect(logRequests()).toHaveLength(1); }); expect(viewer.bodies).toEqual([control(0, "start")]); }); it("streams a running job and closes when the build finishes", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\ntw" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toEqual([control(0, "start"), data(0, "one\n")]); }); logs = { a: "one\ntwo\nthr" }; await tick(); expect(viewer.bodies.slice(2)).toEqual([data(0, "two\n")]); logs = { a: "one\ntwo\nthree" }; await deliver("job.finished", { job: job("a", "passed"), build: webhookBuild("running") }); await vi.waitFor(() => { expect(viewer.bodies.slice(3)).toEqual([ data(0, "three\n"), control(0, "end", { outcome: "success" }), ]); }); build = { ...build, state: "passed", jobs: [job("a", "passed")] }; await deliver("build.finished", { build: webhookBuild("passed") }); expect(await viewer.closed).toBe(1000); expect(viewer.bodies).toHaveLength(5); expect(requests.filter((request) => request.url === buildUrl)).toHaveLength(2); expect(await alarmTime()).toBeNull(); }); it("gives a new viewer the log up to the cursor, then the same broadcast", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const first = await connect(); await vi.waitFor(() => { expect(first.bodies).toHaveLength(2); }); logs = { a: "one\ntwo\n" }; const second = await connect(); await vi.waitFor(() => { expect(second.bodies).toHaveLength(2); }); expect(logRequests()).toHaveLength(2); await tick(); const all = [control(0, "start"), data(0, "one\n"), data(0, "two\n")]; expect(second.bodies).toEqual(all); expect(first.bodies).toEqual(all); }); it("stops a job's log at 2 MiB with a marker", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toHaveLength(2); }); logs = { a: `one\n${"z".repeat(cap)}\n` }; await tick(); expect(viewer.bodies.slice(2)).toEqual([data(0, marker)]); expect(logRequests().at(-1)?.headers.get("range")).toBe(`bytes=-${cap - 4}`); const fetched = logRequests().length; await tick(); expect(logRequests()).toHaveLength(fetched); }); it.each<[string, Record, number, number]>([ [ "few requests remain", { "RateLimit-User-Remaining": "14", "RateLimit-User-Reset": "30" }, 200, 30_000, ], ["Buildkite answers 429", { "RateLimit-User-Reset": "30" }, 429, 30_000], ["the reset time is missing", { "RateLimit-User-Remaining": "0" }, 200, 60_000], ])("waits for the rate limit window when %s", async (_, headers, status, wait) => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(headers, status); await connect(); await vi.waitFor(() => { expect(requests).toHaveLength(1); }); await vi.waitFor(async () => { expect(await alarmTime()).toBeGreaterThan(Date.now() + wait - 5_000); }); expect(await alarmTime()).toBeLessThanOrEqual(Date.now() + wait); expect(logRequests()).toHaveLength(0); }); it("keeps polling when 15 requests remain", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite({ "RateLimit-User-Remaining": "15", "RateLimit-User-Reset": "30" }); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toEqual([control(0, "start"), data(0, "one\n")]); }); }); it("stops when the last viewer leaves", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toHaveLength(2); }); viewer.ws.close(1000); await vi.waitFor(async () => { expect( await runInDurableObject(logsStub(), (_i, state) => state.getWebSockets().length), ).toBe(0); }); const fetched = requests.length; await tick(); expect(requests).toHaveLength(fetched); expect(await alarmTime()).toBeNull(); }); it("sends a joining viewer no broadcast before its replay", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const first = await connect(); await vi.waitFor(() => { expect(first.bodies).toHaveLength(2); }); const { promise, resolve: release } = Promise.withResolvers(); gate = promise; logs = { a: "one\ntwo\n" }; const polled = tick(); await vi.waitFor(() => { expect(logRequests()).toHaveLength(2); }); const second = await connect(); release(); await polled; const all = [control(0, "start"), data(0, "one\n"), data(0, "two\n")]; await vi.waitFor(() => { expect(second.bodies).toEqual(all); }); expect(first.bodies).toEqual(all); }); it("checks a blocked build once a minute without fetching logs", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "blocked", jobs: [job("a", "running")] }; logs = { a: "one\n" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toEqual([control(0, "start")]); }); await vi.waitFor(async () => { expect(await alarmTime()).toBeGreaterThan(Date.now() + 55_000); }); expect(logRequests()).toHaveLength(0); }); it("keeps checking after Buildkite fails", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [] }; logs = {}; mockBuildkite({}, 502); await connect(); await vi.waitFor(() => { expect(requests).toHaveLength(1); }); await vi.waitFor(async () => { expect(await alarmTime()).toBeGreaterThan(Date.now()); }); }); it("ignores job events of another build", async () => { await setup("running"); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(() => { expect(viewer.bodies).toHaveLength(1); }); await logsStub().update(8, undefined, job("b", "running")); await logsStub().update(7, undefined, job("c", "running")); expect(viewer.bodies).toEqual([ control(0, "start"), control(1, "start", { content: "job c" }), ]); }); it("waits for the build of a pending run and asks the store again", async () => { await setup("pending", null); build = { id: "uuid-1", number: 7, state: "running", jobs: [job("a", "running")] }; logs = { a: "" }; mockBuildkite(); const viewer = await connect(); await vi.waitFor(async () => { expect(await alarmTime()).toBeGreaterThan(Date.now() + 5_000); }); expect(requests).toHaveLength(0); await runInDurableObject(exports.Store.getByName("main"), (_instance, state) => { state.storage.sql.exec("UPDATE workflow_runs SET status = 'started', build_number = 7"); }); await tick(); expect(viewer.bodies).toEqual([control(0, "start")]); }); });