Blame · Line-by-line history

`deploy-step-streaming.test.ts`

Each line is annotated with the commit that last touched it. Click any SHA to jump to that commit and see the surrounding change.

deploy-step-streaming.test.tsBlame455 lines · 1 contributor

Normal view Raw

9dd96b9Test User	1	/**
	2	* Block R2 — Live deploy log streaming tests.
	3	*
	4	* Exercises:
	5	* - POST /api/events/deploy/step requires bearer; rejects without
	6	* - validateStep payload validation
	7	* - Step insert + parent rollup + SSE publish on both topics
	8	* - Idempotency on (deploy_id, step_name, status)
	9	* - SSE topic is `platform:deploys:<run_id>` (verified via subscribe())
	10	* - /admin/deploys renders the modal markup (conditionally and always)
	11	*
	12	* Pattern: no mock.module() — same approach as the locked Block N3 test
	13	* file (`platform-deploys.test.ts`). DB-backed assertions degrade
	14	* gracefully to {200,500} when DATABASE_URL is unset.
	15	*
	16	* afterAll cleanup restores DEPLOY_EVENT_TOKEN so subsequent suites in the
	17	* shared bun-test runner inherit a clean env.
	18	*/
	19
	20	import {
	21	afterAll,
	22	afterEach,
	23	beforeAll,
	24	beforeEach,
	25	describe,
	26	expect,
	27	it,
	28	} from "bun:test";
	29	import events, { __test as eventsTest } from "../routes/events";
	30	import { __test as pageTest } from "../routes/admin-deploys-page";
	31	import {
	32	subscribe,
	33	topicSubscriberCount,
	34	type SSEEvent,
	35	} from "../lib/sse";
	36	import app from "../app";
	37
	38	const TOPIC_GLOBAL = "platform:deploys";
	39
	40	const VALID_SHA = "b".repeat(40);
	41	const RUN_R2_A = "r2-test-run-aaaa-0001";
	42	const RUN_R2_B = "r2-test-run-bbbb-0002";
	43	const RUN_R2_C = "r2-test-run-cccc-0003";
	44
	45	const origToken = process.env.DEPLOY_EVENT_TOKEN;
	46	const HAS_DB = Boolean(process.env.DATABASE_URL);
	47
	48	const AUTH = { authorization: "Bearer r2-bearer-fixture" };
	49
	50	async function postStarted(body: unknown) {
	51	return events.request("/deploy/started", {
	52	method: "POST",
	53	headers: { "content-type": "application/json", ...AUTH },
	54	body: JSON.stringify(body),
	55	});
	56	}
	57
	58	async function postStep(
	59	body: unknown,
	60	headers: Record<string, string> = {}
	61	): Promise<Response> {
	62	return events.request("/deploy/step", {
	63	method: "POST",
	64	headers: {
	65	"content-type": "application/json",
	66	...headers,
	67	},
	68	body: typeof body === "string" ? body : JSON.stringify(body),
	69	});
	70	}
	71
	72	beforeAll(() => {
	73	process.env.DEPLOY_EVENT_TOKEN = "r2-bearer-fixture";
	74	});
	75
	76	afterAll(() => {
	77	if (origToken === undefined) delete process.env.DEPLOY_EVENT_TOKEN;
	78	else process.env.DEPLOY_EVENT_TOKEN = origToken;
	79	});
	80
	81	// ---------------------------------------------------------------------------
	82	// Bearer auth
	83	// ---------------------------------------------------------------------------
	84
	85	describe("POST /api/events/deploy/step — bearer auth", () => {
	86	it("rejects with 401 when Authorization header is missing", async () => {
	87	const res = await postStep({
	88	run_id: RUN_R2_A,
	89	sha: VALID_SHA,
	90	step_name: "git-pull",
	91	status: "in_progress",
	92	});
	93	expect(res.status).toBe(401);
	94	});
	95
	96	it("rejects with 401 when bearer token is wrong", async () => {
	97	const res = await postStep(
	98	{
	99	run_id: RUN_R2_A,
	100	sha: VALID_SHA,
	101	step_name: "git-pull",
	102	status: "in_progress",
	103	},
	104	{ authorization: "Bearer nope" }
	105	);
	106	expect(res.status).toBe(401);
	107	});
	108
	109	it("rejects with 401 when DEPLOY_EVENT_TOKEN is unset (refuse-by-default)", async () => {
	110	const saved = process.env.DEPLOY_EVENT_TOKEN;
	111	delete process.env.DEPLOY_EVENT_TOKEN;
	112	try {
	113	const res = await postStep(
	114	{
	115	run_id: RUN_R2_A,
	116	sha: VALID_SHA,
	117	step_name: "git-pull",
	118	status: "in_progress",
	119	},
	120	{ authorization: "Bearer anything" }
	121	);
	122	expect(res.status).toBe(401);
	123	const body = await res.json();
	124	expect(String(body.error).toLowerCase()).toContain("not configured");
	125	} finally {
	126	if (saved !== undefined) process.env.DEPLOY_EVENT_TOKEN = saved;
	127	}
	128	});
	129	});
	130
	131	// ---------------------------------------------------------------------------
	132	// Payload validation — pure helpers
	133	// ---------------------------------------------------------------------------
	134
	135	describe("validateStep — payload validation", () => {
	136	const { validateStep } = eventsTest;
	137
	138	it("accepts a canonical succeeded transition", () => {
	139	const v = validateStep({
	140	run_id: RUN_R2_A,
	141	sha: VALID_SHA,
	142	step_name: "bun-install",
	143	status: "succeeded",
	144	duration_ms: 12_000,
	145	});
	146	expect(v.ok).toBe(true);
	147	if (v.ok) {
	148	expect(v.payload.duration_ms).toBe(12_000);
	149	}
	150	});
	151
	152	it("accepts in_progress without duration", () => {
	153	const v = validateStep({
	154	run_id: RUN_R2_A,
	155	sha: VALID_SHA,
	156	step_name: "smoke-test",
	157	status: "in_progress",
	158	});
	159	expect(v.ok).toBe(true);
	160	});
	161
	162	it("rejects bad status", () => {
	163	const v = validateStep({
	164	run_id: RUN_R2_A,
	165	sha: VALID_SHA,
	166	step_name: "git-pull",
	167	status: "weird",
	168	});
	169	expect(v.ok).toBe(false);
	170	});
	171
	172	it("rejects bad step_name (spaces)", () => {
	173	const v = validateStep({
	174	run_id: RUN_R2_A,
	175	sha: VALID_SHA,
	176	step_name: "git pull",
	177	status: "in_progress",
	178	});
	179	expect(v.ok).toBe(false);
	180	});
	181
	182	it("rejects empty run_id", () => {
	183	const v = validateStep({
	184	run_id: "",
	185	sha: VALID_SHA,
	186	step_name: "git-pull",
	187	status: "in_progress",
	188	});
	189	expect(v.ok).toBe(false);
	190	});
	191
	192	it("rejects non-hex sha", () => {
	193	const v = validateStep({
	194	run_id: RUN_R2_A,
	195	sha: "not-hex!",
	196	step_name: "git-pull",
	197	status: "in_progress",
	198	});
	199	expect(v.ok).toBe(false);
	200	});
	201
	202	it("rejects negative duration_ms", () => {
	203	const v = validateStep({
	204	run_id: RUN_R2_A,
	205	sha: VALID_SHA,
	206	step_name: "git-pull",
	207	status: "succeeded",
	208	duration_ms: -10,
	209	});
	210	expect(v.ok).toBe(false);
	211	});
	212
	213	it("truncates output to 8 KB", () => {
	214	const v = validateStep({
	215	run_id: RUN_R2_A,
	216	sha: VALID_SHA,
	217	step_name: "build",
	218	status: "succeeded",
	219	output: "x".repeat(20_000),
	220	});
	221	expect(v.ok).toBe(true);
	222	if (v.ok) {
	223	expect((v.payload.output \|\| "").length).toBeLessThanOrEqual(8 * 1024);
	224	}
	225	});
	226
	227	it("rejects malformed JSON via HTTP", async () => {
	228	const res = await postStep("{not-json", AUTH);
	229	expect(res.status).toBe(400);
	230	});
	231	});
	232
	233	// ---------------------------------------------------------------------------
	234	// Topic helper
	235	// ---------------------------------------------------------------------------
	236
	237	describe("perDeployTopic — SSE topic shape", () => {
	238	it("composes `platform:deploys:<run_id>`", () => {
	239	expect(eventsTest.perDeployTopic("123abc")).toBe(
	240	"platform:deploys:123abc"
	241	);
	242	});
	243	});
	244
	245	// ---------------------------------------------------------------------------
	246	// DB-backed flow: insert + parent rollup + dual-topic publish + idempotency
	247	// ---------------------------------------------------------------------------
	248
	249	describe("/api/events/deploy/step — insert + publish (DB-aware)", () => {
	250	let receivedGlobal: SSEEvent[] = [];
	251	let receivedPerDeploy: SSEEvent[] = [];
	252	let unsubGlobal: (() => void) \| null = null;
	253	let unsubPerDeploy: (() => void) \| null = null;
	254
	255	const PER_DEPLOY_TOPIC_A = `platform:deploys:${RUN_R2_A}`;
	256
	257	beforeEach(() => {
	258	receivedGlobal = [];
	259	receivedPerDeploy = [];
	260	unsubGlobal = subscribe(TOPIC_GLOBAL, (e) => receivedGlobal.push(e));
	261	unsubPerDeploy = subscribe(PER_DEPLOY_TOPIC_A, (e) =>
	262	receivedPerDeploy.push(e)
	263	);
	264	});
	265
	266	afterEach(() => {
	267	if (unsubGlobal) unsubGlobal();
	268	if (unsubPerDeploy) unsubPerDeploy();
	269	unsubGlobal = null;
	270	unsubPerDeploy = null;
	271	expect(topicSubscriberCount(TOPIC_GLOBAL)).toBe(0);
	272	expect(topicSubscriberCount(PER_DEPLOY_TOPIC_A)).toBe(0);
	273	});
	274
	275	it("404s when no platform_deploys row exists for run_id", async () => {
	276	const res = await postStep(
	277	{
	278	run_id: "r2-never-started-run",
	279	sha: VALID_SHA,
	280	step_name: "git-pull",
	281	status: "in_progress",
	282	},
	283	AUTH
	284	);
	285	// With DB → strict 404. Without DB → the parent lookup throws and
	286	// returns 500 — we accept both so the test suite remains green in
	287	// dev sandboxes.
	288	expect([404, 500]).toContain(res.status);
	289	});
	290
	291	it("first step posts: row + parent rollup + SSE publish on both topics", async () => {
	292	// Seed the parent so /step has something to attach to.
	293	const started = await postStarted({
	294	run_id: RUN_R2_A,
	295	sha: VALID_SHA,
	296	source: "hetzner-deploy",
	297	});
	298	// Drop any 'deploy.started' event from the global topic so our
	299	// assertions only count step publishes.
	300	receivedGlobal = [];
	301
	302	const res = await postStep(
	303	{
	304	run_id: RUN_R2_A,
	305	sha: VALID_SHA,
	306	step_name: "git-pull",
	307	status: "in_progress",
	308	},
	309	AUTH
	310	);
	311
	312	if (HAS_DB && started.status === 200) {
	313	expect(res.status).toBe(200);
	314	const body = await res.json();
	315	expect(body.ok).toBe(true);
	316	expect(body.duplicate).toBe(false);
	317
	318	// SSE: both topics should have received the publish.
	319	expect(receivedGlobal.length).toBe(1);
	320	expect(receivedPerDeploy.length).toBe(1);
	321	expect(receivedPerDeploy[0]?.event).toBe("step");
	322	const parsed = JSON.parse(receivedPerDeploy[0]?.data as string);
	323	expect(parsed.step_name).toBe("git-pull");
	324	expect(parsed.status).toBe("in_progress");
	325	expect(parsed.run_id).toBe(RUN_R2_A);
	326	} else {
	327	// No DB → /step returns 404 or 500 and never publishes.
	328	expect([404, 500]).toContain(res.status);
	329	expect(receivedGlobal.length).toBe(0);
	330	expect(receivedPerDeploy.length).toBe(0);
	331	}
	332	});
	333
	334	it("idempotent: replaying (deploy_id, step_name, status) returns duplicate:true and does NOT republish", async () => {
	335	// Seed the parent.
	336	const started = await postStarted({
	337	run_id: RUN_R2_B,
	338	sha: VALID_SHA,
	339	source: "hetzner-deploy",
	340	});
	341	if (!HAS_DB \|\| started.status !== 200) {
	342	// Without DB this branch is exercised by the validator + bearer
	343	// tests; skip the live duplicate-roundtrip check here.
	344	return;
	345	}
	346
	347	// Subscribe to the per-deploy topic for RUN_R2_B specifically.
	348	const perB = `platform:deploys:${RUN_R2_B}`;
	349	let perBEvents: SSEEvent[] = [];
	350	const stop = subscribe(perB, (e) => perBEvents.push(e));
	351	try {
	352	const first = await postStep(
	353	{
	354	run_id: RUN_R2_B,
	355	sha: VALID_SHA,
	356	step_name: "bun-install",
	357	status: "succeeded",
	358	duration_ms: 4_200,
	359	},
	360	AUTH
	361	);
	362	expect(first.status).toBe(200);
	363	const firstBody = await first.json();
	364	expect(firstBody.duplicate).toBe(false);
	365	const eventsAfterFirst = perBEvents.length;
	366
	367	const second = await postStep(
	368	{
	369	run_id: RUN_R2_B,
	370	sha: VALID_SHA,
	371	step_name: "bun-install",
	372	status: "succeeded",
	373	duration_ms: 4_200,
	374	},
	375	AUTH
	376	);
	377	expect(second.status).toBe(200);
	378	const secondBody = await second.json();
	379	expect(secondBody.duplicate).toBe(true);
	380	// No new SSE event from the duplicate.
	381	expect(perBEvents.length).toBe(eventsAfterFirst);
	382	} finally {
	383	stop();
	384	}
	385	});
	386
	387	it("publishes on the EXACT per-deploy topic platform:deploys:<run_id>", async () => {
	388	// Seed parent.
	389	const started = await postStarted({
	390	run_id: RUN_R2_C,
	391	sha: VALID_SHA,
	392	source: "hetzner-deploy",
	393	});
	394	if (!HAS_DB \|\| started.status !== 200) return;
	395
	396	const perC = `platform:deploys:${RUN_R2_C}`;
	397	let perCEvents: SSEEvent[] = [];
	398	const stop = subscribe(perC, (e) => perCEvents.push(e));
	399	try {
	400	const res = await postStep(
	401	{
	402	run_id: RUN_R2_C,
	403	sha: VALID_SHA,
	404	step_name: "smoke-test",
	405	status: "succeeded",
	406	duration_ms: 1_500,
	407	},
	408	AUTH
	409	);
	410	expect(res.status).toBe(200);
	411	expect(perCEvents.length).toBe(1);
	412	expect(perCEvents[0]?.event).toBe("step");
	413	const parsed = JSON.parse(perCEvents[0]?.data as string);
	414	expect(parsed.run_id).toBe(RUN_R2_C);
	415	expect(parsed.step_name).toBe("smoke-test");
	416	expect(parsed.status).toBe("succeeded");
	417	expect(parsed.duration_ms).toBe(1_500);
	418	} finally {
	419	stop();
	420	}
	421	});
	422	});
	423
	424	// ---------------------------------------------------------------------------
	425	// /admin/deploys page — modal markup is always rendered (hidden by default)
	426	// ---------------------------------------------------------------------------
	427
	428	describe("/admin/deploys page — modal markup", () => {
	429	it("R2_STEP_ORDER lists the 7 canonical steps in order", () => {
	430	const names = pageTest.R2_STEP_ORDER.map((s) => s.name);
	431	expect(names).toEqual([
	432	"setup",
	433	"git-pull",
	434	"bun-install",
	435	"build",
	436	"db-migrate",
	437	"restart-service",
	438	"smoke-test",
	439	]);
	440	});
	441
	442	it("inline modal JS subscribes to the platform:deploys:<run_id> topic", () => {
	443	const js = pageTest.DEPLOY_MODAL_JS;
	444	expect(typeof js).toBe("string");
	445	expect(js).toContain("platform:deploys:");
	446	expect(js).toContain("/live-events/");
	447	expect(js).toContain("EventSource");
	448	expect(js).toContain("data-step");
	449	});
	450
	451	it("does not 404 — route is registered + responds to anonymous", async () => {
	452	const res = await app.request("/admin/deploys", { redirect: "manual" });
	453	expect(res.status).not.toBe(404);
	454	});
	455	});