import { describe, it, expect } from "bun:test"; import { authLogin, claimLogin } from "../server/lib/web/session"; import { BeforeGitHubError, commentAsUser } from "../server/lib/github/oauth"; import { kvConfigStore, d1ConfigStore } from "../server/lib/storage/config-store"; import { createInvite, deleteGroupInvites, getInvite } from "../server/lib/web/invites"; import { loadFragments, saveGroupFragments } from "../server/lib/fragments"; import { handleQueueBatch } from "../server/lib/queue/consumer"; import { dispatchEvent } from "../server/lib/core/dispatch"; import { customProvider } from "../server/lib/providers/custom"; import { renderNeutralMessage as renderTelegram } from "../server/lib/drivers/telegram/render"; import { listInvites } from "../server/lib/web/invites"; import { sendMessage as discordSend } from "../server/lib/drivers/discord/rest"; import type { DeliveryMessage } from "../server/lib/queue/delivery"; import type { Config, Env, Group, Route } from "../server/lib/types"; import { createMemoryKV, createSqliteD1 } from "./d1-sqlite"; const route = (id: string, groupId: string): Route => ({ id, name: id, enabled: true, filters: [{ type: "event", match: "push" }], targets: [{ platform: "discord", channelId: "c1" }], groupId, }); describe("login ownership", () => { it("never lets a second account inherit what was granted to a login", async () => { const { kv } = createMemoryKV(); expect(await claimLogin(kv, "42", "alice")).toBe(true); expect(await claimLogin(kv, "42", "Alice")).toBe(true); // The name was renamed away and registered by someone else. expect(await claimLogin(kv, "77", "alice")).toBe(false); expect(authLogin({ userId: "77", login: "alice", loginTrusted: false })).toBe(""); expect(authLogin({ userId: "42", login: "alice" })).toBe("alice"); }); }); describe("payload shapes", () => { it("refuses a top-level JSON array from the custom provider", () => { expect(customProvider.parse("[1,2,3]", {})).toBeNull(); expect(customProvider.parse('{"a":1}', {})?.payload).toEqual({ a: 1 }); }); it("never renders a Markdown hard break as the
Telegram rejects", () => { const html = renderTelegram({ title: "t", description: "first line \nsecond line" }); expect(html).not.toContain(" { it("tells a failure before GitHub was called from a GitHub answer", async () => { const { kv } = createMemoryKV(); kv.get = (async () => { throw new Error("KV down"); }) as typeof kv.get; await expect(commentAsUser(kv, "42", "o", "r", 1, "hi")).rejects.toBeInstanceOf( BeforeGitHubError, ); }); }); describe("configuration leftovers", () => { it("never hands routes left under an id to a new group created with it (KV-only)", async () => { const { kv, store } = createMemoryKV(); store.set("config:groups", JSON.stringify([])); // Copies an interrupted rename left behind. store.set("config:routes", JSON.stringify([route("leftover", "b")])); const cfg = kvConfigStore(kv); expect(await cfg.createGroup({ id: "b", name: "B", adminIds: [] })).toBe(true); expect((await cfg.loadRoutes()).filter((r) => r.groupId === "b")).toEqual([]); }); it("seeds routes of a missing group into an isolated placeholder, not an open one", async () => { const { db } = createSqliteD1(); const { kv, store } = createMemoryKV(); store.set("config:groups", JSON.stringify([])); store.set( "config:routes", JSON.stringify([route("r1", "deleted-private"), { ...route("r2", ""), groupId: undefined }]), ); const groups = await d1ConfigStore(db, kv).loadGroups({ fresh: true }); const placeholder = groups.find((g) => g.id === "deleted-private"); expect(placeholder?.isolated).toBe(true); // A new identity: the deleted group's secret and invites never apply to it. expect(placeholder?.instance).toBeTruthy(); expect(placeholder?.legacyId).toBeUndefined(); expect(groups.find((g) => g.id !== "deleted-private")?.isolated).toBeUndefined(); }); it("refuses to replace a group's fragments while one of them is unreadable", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); await d1ConfigStore(db, kv).createGroup({ id: "g", name: "G", adminIds: [] }); sqlite.exec( "INSERT INTO d1_fragments (id, group_id, name, node, created_at, updated_at) VALUES ('bad', 'g', 'B', '{oops', 1, 1)", ); expect(await loadFragments(db, "g")).toEqual([]); await expect(saveGroupFragments(db, "g", [])).rejects.toThrow(/unreadable/); expect(sqlite.query("SELECT COUNT(*) AS n FROM d1_fragments").get()).toEqual({ n: 1 }); }); }); describe("invites of a former id holder", () => { it("lists a pre-instance invite still filed under the group's former id", async () => { const { kv } = createMemoryKV(); const token = await createInvite(kv, { groupId: "old", role: "viewer", expiresAt: Date.now() + 86400_000, createdBy: "x", }); // Renamed old -> new; moving the invite failed. const listed = await listInvites(kv, "new", { instance: "i1", legacyId: "old" }); expect(listed.map((i) => i.token)).toEqual([token]); }); it("deleting a group keeps the invites another group issued under the same id", async () => { const { kv } = createMemoryKV(); const foreign = await createInvite(kv, { groupId: "a", role: "viewer", expiresAt: Date.now() + 86400_000, createdBy: "x", groupInstance: "renamed-away", }); const own = await createInvite(kv, { groupId: "a", role: "viewer", expiresAt: Date.now() + 86400_000, createdBy: "y", groupInstance: "current", }); await deleteGroupInvites(kv, "a", { instance: "current" }); expect(await getInvite(kv, own)).toBeNull(); expect(await getInvite(kv, foreign)).not.toBeNull(); }); }); describe("queue safety", () => { it("leaves a delivery and its payload alone while another copy holds a live lease", async () => { const { db, sqlite } = createSqliteD1(); const { kv, store } = createMemoryKV(); const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db }; sqlite.exec( `INSERT INTO delivery_state (key, status, updated_at) VALUES ('delivery-state:github:@global:d1', 'processing', ${Date.now()})`, ); store.set("queue:payload:x", "{}"); const body: DeliveryMessage = { deliveryId: "d1", provider: "github", event: "push", payloadRef: "queue:payload:x", payloadRefType: "kv", receivedAt: Date.now(), }; let acked = false; let retried: unknown = null; const message = { body, attempts: 1, ack: (): void => { acked = true; }, retry: (opts: unknown): void => { retried = opts; }, }; await handleQueueBatch( { queue: "webhooker-delivery-dlq", messages: [message], } as unknown as MessageBatch, env, ); expect(acked).toBe(false); expect(retried).toEqual({ delaySeconds: 310 }); expect(store.has("queue:payload:x")).toBe(true); }); it("leaves a group with an unreadable route out whole — its fallback included", async () => { let sends = 0; const realFetch = globalThis.fetch; globalThis.fetch = (async () => { sends += 1; return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, // The regular route that would have matched is the unreadable one. routes: [{ ...route("fb", "g"), fallback: true }], unreadableGroups: ["g"], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [] }]; const summary = await dispatchEvent(config, { event: "push", payload: {} }, env, groups); expect(sends).toBe(0); expect(summary.failures).toHaveLength(1); } finally { globalThis.fetch = realFetch; } }); it("matches each regular route once per dispatch", async () => { const { matchRoute } = await import("../server/lib/events/match"); let reads = 0; const probed = (): Record => { const payload: Record = {}; Object.defineProperty(payload, "probe", { enumerable: true, get: () => { reads++; return "no"; }, }); return payload; }; const r: Route = { ...route("r", "g"), filters: [{ type: "field", path: "probe", op: "eq", match: "yes" }], }; expect(matchRoute(r, { event: "push", payload: probed() })).toBe(false); const once = reads; reads = 0; const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [r], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [] }]; await dispatchEvent(config, { event: "push", payload: probed() }, env, groups); expect(once).toBeGreaterThan(0); expect(reads).toBe(once); }); it("reports a group with an unreadable route as a transient failure", async () => { const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [], unreadableGroups: ["g"], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [] }]; const summary = await dispatchEvent(config, { event: "push", payload: {} }, env, groups); expect(summary.failures).toHaveLength(1); expect(summary.failures[0]!.errorCode).toBeUndefined(); }); }); describe("lost send responses", () => { it("retries a Discord create with the same enforced nonce", async () => { const bodies: Array<{ nonce?: string; enforce_nonce?: boolean }> = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { bodies.push(JSON.parse(String(init?.body))); // The first create went through, but its response was lost. if (bodies.length === 1) throw new Error("connection reset"); return new Response(JSON.stringify({ id: "m1" }), { status: 200 }); }) as unknown as typeof fetch; try { const result = await discordSend("t", "123", { content: "hi" }); expect(result.ok).toBe(true); } finally { globalThis.fetch = realFetch; } expect(bodies).toHaveLength(2); expect(bodies[0]!.enforce_nonce).toBe(true); expect(bodies[1]!.nonce).toBe(bodies[0]!.nonce); expect(bodies[0]!.nonce!.length).toBeLessThanOrEqual(25); }); }); describe("send keys", () => { it("gives every attempt of a delivery to a target the same platform nonce", async () => { const nonces: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { nonces.push((JSON.parse(String(init?.body)) as { nonce: string }).nonce); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [route("r", "g")], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; for (const deliveryId of ["d1", "d1", "d2"]) { await dispatchEvent(config, { event: "push", payload: {}, deliveryId }, env, groups); } } finally { globalThis.fetch = realFetch; } expect(nonces).toHaveLength(3); expect(nonces[1]).toBe(nonces[0]); expect(nonces[2]).not.toBe(nonces[0]); }); }); describe("pre-instance message chains", () => { it("are adopted only by the group that had the id back then", async () => { const event = { event: "check_run", deliveryId: "d", payload: { action: "completed", check_run: { id: 1, name: "build", head_sha: "abc", status: "completed", conclusion: "success", check_suite: { id: 7 }, }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }, }; for (const [legacyId, expected] of [ [undefined, "POST"], ["g", "PATCH"], ] as const) { const { db, sqlite } = createSqliteD1(); sqlite.exec( `INSERT INTO message_tracking (event_id, target_id, message_id, updated_at) VALUES ('g:r:check_run:o/r:build:abc', 'c1', 'old-message', 1)`, ); const methods: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { methods.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [{ type: "event", match: "check_run" }] }], }; // A group re-created under the id has a fresh instance and no legacyId. const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i", legacyId }]; await dispatchEvent(config, event, env, groups); } finally { globalThis.fetch = realFetch; } expect(methods).toEqual([expected]); } }); }); describe("one-time identity migration", () => { it("trusts no identity field stored before the server assigned them", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); // Rows as the old API stored them: an owner wrote identity fields freely. sqlite.exec( `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('victim', 'V', '{"id":"victim","name":"V","adminIds":[]}', 1, 0, 0), ('zz-attacker', 'A', '{"id":"zz-attacker","name":"A","adminIds":[],"instance":"same","legacyId":"victim","instanceBackfilled":true}', 1, 0, 0), ('zz-other', 'O', '{"id":"zz-other","name":"O","adminIds":[],"instance":"same"}', 1, 0, 0)`, ); const groups = await d1ConfigStore(db, kv).loadGroups({ fresh: true }); const byId = new Map(groups.map((g) => [g.id, g])); expect(byId.get("zz-attacker")!.legacyId).toBe("zz-attacker"); expect(byId.get("victim")!.legacyId).toBe("victim"); const instances = groups.map((g) => g.instance); expect(new Set(instances).size).toBe(3); expect(instances).not.toContain("same"); }); it("seeds ungrouped legacy routes into a group of their own, never a tenant's", async () => { const { db } = createSqliteD1(); const { kv, store } = createMemoryKV(); store.set( "config:groups", JSON.stringify([{ id: "ungrouped", name: "Tenant", adminIds: ["mallory"] }]), ); store.set("config:routes", JSON.stringify([{ ...route("global", ""), groupId: undefined }])); const cfg = d1ConfigStore(db, kv); const routes = await cfg.loadRoutes({ fresh: true }); expect(routes.map((r) => r.groupId)).toEqual(["ungrouped-2"]); const placeholder = (await cfg.loadGroups()).find((g) => g.id === "ungrouped-2")!; expect(placeholder.adminIds).toEqual([]); }); }); describe("update chain versions", () => { it("never lets a late in-progress event undo a completion stamped the same time", async () => { const calls: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { calls.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; const run = (status: string, conclusion: string | null): Record => ({ workflow_run: { id: 5, workflow_id: 9, name: "CI", status, conclusion, updated_at: "2026-10-01T00:00:00Z", html_url: "https://github.com/o/r/actions/runs/5", }, workflow: { id: 9, name: "CI" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [{ type: "event", match: "workflow_run" }] }], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; await dispatchEvent( config, { event: "workflow_run", payload: run("completed", "failure") }, env, groups, ); await dispatchEvent( config, { event: "workflow_run", payload: run("in_progress", null) }, env, groups, ); } finally { globalThis.fetch = realFetch; } // The completion was posted; the stale in-progress state never edits it. expect(calls).toEqual(["POST"]); }); }); describe("identity migration edge cases", () => { it("keeps identities a KV-only deployment already manages when moving to D1", async () => { const { db } = createSqliteD1(); const { kv, store } = createMemoryKV(); store.set( "config:groups", JSON.stringify([ { id: "g", name: "G", adminIds: [], instance: "A", legacyId: "g", instanceBackfilled: true, }, ]), ); store.set("config:identity-migrated", "1"); const groups = await d1ConfigStore(db, kv).loadGroups({ fresh: true }); expect(groups[0]!.instance).toBe("A"); }); it("only records the migration once the table exists, after a KV-marked run", async () => { const { db, sqlite } = createSqliteD1(); const { kv, store } = createMemoryKV(); store.set("config:identity-migrated", "1"); sqlite.exec( `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('new', 'N', '{"id":"new","name":"N","adminIds":[],"instance":"i1","legacyId":"old","instanceBackfilled":true}', 1, 0, 0)`, ); const groups = await d1ConfigStore(db, kv).loadGroups({ fresh: true }); expect(groups[0]!.legacyId).toBe("old"); expect(groups[0]!.instance).toBe("i1"); }); it("never keeps a stored instance in the KV-only migration", async () => { // The instance the migration derives for "victim"... const { kv, store } = createMemoryKV(); store.set("config:groups", JSON.stringify([{ id: "victim", name: "V", adminIds: [] }])); const derived = (await kvConfigStore(kv).loadGroups())[0]!.instance!; // ...pre-filled by an attacker on their own group before the upgrade. const { kv: kv2, store: store2 } = createMemoryKV(); store2.set( "config:groups", JSON.stringify([ { id: "victim", name: "V", adminIds: [] }, { id: "zz", name: "Z", adminIds: [], instance: derived }, ]), ); const groups = await kvConfigStore(kv2).loadGroups(); expect(new Set(groups.map((g) => g.instance)).size).toBe(2); }); }); describe("pattern usability", () => { it("judges what the matcher runs: AST over flat filters, literals not as regexes", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); const cfg = d1ConfigStore(db, kv); await cfg.createGroup({ id: "g", name: "G", adminIds: [] }); await cfg.saveGroupRoutes("g", [route("r1", "g"), route("r2", "g"), route("r3", "g")]); sqlite.exec(`UPDATE d1_routes SET filters = '[{"type":"repo","match":"/^a(?=b)/"}]', ast = '{"type":"event","match":"push"}' WHERE id = 'r1'`); sqlite.exec( `UPDATE d1_routes SET filters = '[{"type":"repo","op":"contains","match":"/(?=foo)/"}]' WHERE id = 'r2'`, ); expect((await cfg.loadSnapshot({ fresh: true })).unreadable).toEqual([]); // A glob longer than the matcher compiles is not usable. sqlite.exec( `UPDATE d1_routes SET filters = '[{"type":"branch","match":"${"a".repeat(201)}*","exclude":true}]' WHERE id = 'r3'`, ); expect((await cfg.loadSnapshot({ fresh: true })).unreadable).toEqual(["g"]); }); }); describe("upgrade compatibility", () => { it("never re-sends a tenant delivery finished under the key used before the upgrade", async () => { const { kv, store } = createMemoryKV(); store.set( "config:groups", JSON.stringify([ { id: "team", name: "T", adminIds: [], instance: "ti", legacyId: "team", instanceBackfilled: true, }, ]), ); store.set("config:identity-migrated", "1"); // Finished before the upgrade (state keyed `{provider}:{groupId}:{id}`). store.set("delivery-state:github:team:d1", JSON.stringify({ status: "delivered", at: 1 })); // The global endpoint's old key: its owner is never certain. store.set("delivery-state:github:global:d2", JSON.stringify({ status: "delivered", at: 1 })); const run = async (body: Partial): Promise => { let dispatched = 0; const message = { body: { provider: "github", event: "push", payload: {}, receivedAt: Date.now(), stateVersion: 2, ...body, } as DeliveryMessage, attempts: 1, ack: (): void => {}, retry: (): void => {}, }; await handleQueueBatch( { queue: "webhooker-delivery", messages: [message], } as unknown as MessageBatch, { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: {} as D1Database }, async () => { dispatched += 1; return { attempts: 0, failures: [] }; }, ); return dispatched; }; expect(await run({ deliveryId: "d1", groupId: "team", groupInstance: "ti" })).toBe(0); // Sent again rather than dropped. expect(await run({ deliveryId: "d2" })).toBe(1); }); it("refuses to serve configuration while the marker table is missing", async () => { const { db, sqlite } = createSqliteD1({ migrations: (name) => !name.startsWith("0008") && !name.startsWith("0013"), }); sqlite.exec( `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('g', 'G', '{"id":"g","name":"G","adminIds":[]}', 1, 0, 0)`, ); // Identities can neither be trusted unmigrated nor migrated safely: fail. await expect( d1ConfigStore(db, createMemoryKV().kv).loadGroups({ fresh: true }), ).rejects.toThrow(/migrations are incomplete/); }); }); describe("mixed filter nodes", () => { it("counts a stored node mixing condition kinds as one unreadable route", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); const cfg = d1ConfigStore(db, kv); await cfg.createGroup({ id: "g", name: "G", adminIds: [] }); await cfg.createGroup({ id: "h", name: "H", adminIds: [] }); await cfg.saveGroupRoutes("g", [route("r1", "g")]); await cfg.saveGroupRoutes("h", [route("r2", "h")]); sqlite.exec( `UPDATE d1_routes SET ast = '{"all":0,"any":[{"type":"event","match":"push"}]}' WHERE id = 'r1'`, ); // The snapshot still loads: only that group is affected. const snapshot = await cfg.loadSnapshot({ fresh: true }); expect(snapshot.unreadable).toEqual(["g"]); expect(snapshot.routes.map((r) => r.id)).toEqual(["r2"]); }); }); describe("old global-endpoint state", () => { it("is never trusted when a tenant named global existed at the upgrade", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); sqlite.exec( `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('global', 'Tenant', '{"id":"global","name":"Tenant","adminIds":[]}', 1, 0, 0)`, ); // Its state, written before the upgrade under the shared key. sqlite.exec( `INSERT INTO delivery_state (key, status, updated_at) VALUES ('delivery-state:github:global:d1', 'delivered', 1)`, ); let dispatched = 0; const message = { body: { deliveryId: "d1", provider: "github", event: "push", payload: {}, receivedAt: Date.now(), stateVersion: 2, } as DeliveryMessage, attempts: 1, ack: (): void => {}, retry: (): void => {}, }; await handleQueueBatch( { queue: "webhooker-delivery", messages: [message], } as unknown as MessageBatch, { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db }, async () => { dispatched += 1; return { attempts: 0, failures: [] }; }, ); // A global-endpoint event with that id is dispatched, not taken for done. expect(dispatched).toBe(1); }); }); describe("old tenant state", () => { it("is not read for a group created since (no older id of that name)", async () => { const { db, sqlite } = createSqliteD1(); const { kv, store } = createMemoryKV(); // Identities managed by this server already (the group keeps its instance). store.set("config:identity-migrated", "1"); sqlite.exec( `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('team', 'Team', '{"id":"team","name":"Team","adminIds":[],"instance":"ti"}', 1, 0, 0)`, ); // Left by an earlier group of that id. sqlite.exec( `INSERT INTO delivery_state (key, status, updated_at) VALUES ('delivery-state:github:team:d1', 'delivered', 1)`, ); const legacyReads: unknown[] = []; const prepare = db.prepare.bind(db); db.prepare = ((sql: string) => { const stmt = prepare(sql); const bind = stmt.bind.bind(stmt); stmt.bind = ((...args: unknown[]) => { if (args.includes("delivery-state:github:team:d1")) legacyReads.push(sql); return bind(...args); }) as typeof stmt.bind; return stmt; }) as typeof db.prepare; let dispatched = 0; const message = { body: { deliveryId: "d1", provider: "github", groupId: "team", groupInstance: "ti", event: "push", payload: {}, receivedAt: Date.now(), stateVersion: 2, } as DeliveryMessage, attempts: 1, ack: (): void => {}, retry: (): void => {}, }; await handleQueueBatch( { queue: "webhooker-delivery", messages: [message], } as unknown as MessageBatch, { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db }, async () => { dispatched += 1; return { attempts: 0, failures: [] }; }, ); expect(dispatched).toBe(1); expect(legacyReads).toEqual([]); }); }); describe("legacy global tenant", () => { it("never takes the shared old state key for its own", async () => { const { kv, store } = createMemoryKV(); store.set( "config:groups", JSON.stringify([ { id: "global", name: "T", adminIds: [], instance: "gi", legacyId: "global", instanceBackfilled: true, }, ]), ); store.set("config:identity-migrated", "1"); // The global endpoint's delivery, finished before the upgrade. store.set("delivery-state:custom:global:42", JSON.stringify({ status: "delivered", at: 1 })); let dispatched = 0; const message = { body: { deliveryId: "42", provider: "custom", groupId: "global", groupInstance: "gi", event: "custom", payload: {}, receivedAt: Date.now(), stateVersion: 2, } as DeliveryMessage, attempts: 1, ack: (): void => {}, retry: (): void => {}, }; await handleQueueBatch( { queue: "webhooker-delivery", messages: [message], } as unknown as MessageBatch, { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: {} as D1Database }, async () => { dispatched += 1; return { attempts: 0, failures: [] }; }, ); expect(dispatched).toBe(1); }); }); describe("revocation reaches every location at once", () => { it("stops a signed-out session and a revoked token even where KV still has them", async () => { const { createAdminSession, getAdminSession, destroyAdminSession, adminCookie } = await import("../server/lib/web/session"); const { saveToken, removeToken, findUserIdByToken } = await import("../server/lib/github/store"); const { db } = createSqliteD1(); const { kv } = createMemoryKV(); const id = await createAdminSession(kv, "42", "alice"); const cookie = adminCookie(id).split(";")[0]!; const stale = await kv.get(`session:${id}`); await destroyAdminSession(kv, cookie, db); // A location that has not seen the delete yet still holds the session. await kv.put(`session:${id}`, stale!); expect(await getAdminSession(kv, cookie, db)).toBeNull(); await saveToken(kv, "42", "tok-1", 3600, db); const staleToken = await kv.get("token:42"); await removeToken(kv, "42", db); await kv.put("token:42", staleToken!); expect(await findUserIdByToken(kv, "tok-1", db)).toBeNull(); }); it("never falls back to an older KV secret once the group's secret was removed", async () => { const { getTenantSecret } = await import("../server/lib/web/tenants"); const { kv } = createMemoryKV(); await kv.put("tenant:i:inst", "old-secret"); expect(await getTenantSecret(kv, { id: "g", instance: "inst", webhookSecret: "" })).toBeNull(); expect(await getTenantSecret(kv, { id: "g", instance: "inst" })).toBe("old-secret"); }); it("isolates a group row whose fields have the wrong shape", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); const cfg = d1ConfigStore(db, kv); await cfg.createGroup({ id: "g", name: "G", adminIds: [] }); await cfg.saveGroupRoutes("g", [route("r1", "g")]); sqlite.exec( `UPDATE d1_groups SET data = json_set(data, '$.providers', 'github') WHERE id = 'g'`, ); expect((await cfg.loadSnapshot({ fresh: true })).unreadable).toEqual(["g"]); }); }); describe("round 23", () => { it("never takes a Feishu 200 it could not read for a sent message", async () => { const { sendMessage } = await import("../server/lib/drivers/feishu/rest"); const realFetch = globalThis.fetch; globalThis.fetch = (async () => new Response("{cut off", { status: 200 })) as unknown as typeof fetch; try { const result = await sendMessage("t", "oc_1", { a: 1 }); expect(result.ok).toBe(false); } finally { globalThis.fetch = realFetch; } }, 15_000); it("gives bot actions no token that was revoked, even where KV still has it", async () => { const { saveToken, removeToken, getToken } = await import("../server/lib/github/store"); const { db } = createSqliteD1(); const { kv } = createMemoryKV(); await saveToken(kv, "42", "tok-1", 3600, db); const stale = await kv.get("token:42"); await removeToken(kv, "42", db); await kv.put("token:42", stale!); expect(await getToken({ KV: kv, DB: db }, "42")).toBeNull(); }); it("serves the configuration of a fresh isolate despite a malformed group row", async () => { const { db, sqlite } = createSqliteD1(); const { kv } = createMemoryKV(); await d1ConfigStore(db, kv).createGroup({ id: "ok", name: "OK", adminIds: [] }); sqlite.exec( "INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('bad', 'B', '{', 1, 0, 0)", ); const groups = await d1ConfigStore(db, kv).loadGroups({ fresh: true }); expect(groups.map((g) => g.id)).toEqual(["ok"]); }); }); describe("round 24", () => { it("keys platform idempotency by the receiving endpoint too", async () => { const nonces: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { nonces.push((JSON.parse(String(init?.body)) as { nonce: string }).nonce); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [route("r", "g")], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; const event = { event: "push", payload: {}, deliveryId: "42" }; await dispatchEvent(config, event, env, groups); await dispatchEvent(config, event, env, groups, { tenantId: "g" }); } finally { globalThis.fetch = realFetch; } // Same delivery id on two endpoints: two events, two messages. expect(nonces).toHaveLength(2); expect(nonces[1]).not.toBe(nonces[0]); }); it("revokes the old token before a rotation overwrites it", async () => { const { saveToken } = await import("../server/lib/github/store"); const { kv } = createMemoryKV(); const { db } = createSqliteD1(); await saveToken(kv, "42", "tok-A", 3600, db); const broken = { ...db, batch: db.batch.bind(db), prepare: (): never => { throw new Error("D1 down"); }, } as unknown as D1Database; await expect(saveToken(kv, "42", "tok-B", 3600, broken)).rejects.toThrow(); // Not overwritten: a retry still knows which token to revoke. expect(JSON.parse((await kv.get("token:42"))!).accessToken).toBe("tok-A"); }); it("never lets a late pending deployment status undo a success stamped the same time", async () => { const calls: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { calls.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; const status = (state: string): Record => ({ deployment_status: { id: 1, state, updated_at: "2026-10-01T00:00:00Z" }, deployment: { id: 7, environment: "prod", ref: "main", sha: "abc" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [{ type: "event", match: "deployment_status" }] }], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; await dispatchEvent( config, { event: "deployment_status", payload: status("success") }, env, groups, ); await dispatchEvent( config, { event: "deployment_status", payload: status("pending") }, env, groups, ); } finally { globalThis.fetch = realFetch; } expect(calls).toEqual(["POST"]); }); }); describe("group webhook log", () => { it("posts one summary per delivery outcome, not one per retry", async () => { const posts: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (url: unknown) => { posts.push(String(url)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [route("r", "g")], }; const groups: Group[] = [ { id: "g", name: "G", adminIds: [], instance: "i", logTarget: { platform: "discord", channelId: "log" }, }, ]; const event = { event: "push", payload: {}, deliveryId: "d1" }; await dispatchEvent(config, event, env, groups); await dispatchEvent(config, event, env, groups); } finally { globalThis.fetch = realFetch; } expect(posts.filter((u) => u.includes("/channels/log/"))).toHaveLength(1); }); }); describe("round 26", () => { it("stops a newer token even when the removal read an older one from KV", async () => { const { saveToken, removeToken, getToken, findUserIdByToken } = await import("../server/lib/github/store"); const { db } = createSqliteD1(); const { kv } = createMemoryKV(); await saveToken(kv, "42", "tok-0", 3600, db); const older = await kv.get("token:42"); await saveToken(kv, "42", "tok-1", 3600, db); const newer = await kv.get("token:42"); const newerReverse = await kv.get("token-reverse:" + (await sha256("tok-1"))); // The removing location still sees tok-0. await kv.put("token:42", older!); await removeToken(kv, "42", db); // Another location still sees tok-1. await kv.put("token:42", newer!); await kv.put("token-reverse:" + (await sha256("tok-1")), newerReverse!); expect(await getToken({ KV: kv, DB: db }, "42")).toBeNull(); expect(await findUserIdByToken(kv, "tok-1", db)).toBeNull(); // A later sign-in works again. await saveToken(kv, "42", "tok-2", 3600, db); expect(await getToken({ KV: kv, DB: db }, "42")).toBe("tok-2"); expect(await findUserIdByToken(kv, "tok-2", db)).toBe("42"); }); it("keeps a rotation's older token out even where KV still shows it", async () => { const { saveToken, getToken } = await import("../server/lib/github/store"); const { db } = createSqliteD1(); const { kv } = createMemoryKV(); await saveToken(kv, "42", "tok-0", 3600, db); await saveToken(kv, "42", "tok-1", 3600, db); const newer = await kv.get("token:42"); // A rotation working from a stale copy (tok-0) still retires tok-1. await kv.put("token:42", JSON.stringify({ ...JSON.parse(newer!), accessToken: "tok-0" })); await saveToken(kv, "42", "tok-2", 3600, db); await kv.put("token:42", newer!); expect(await getToken({ KV: kv, DB: db }, "42")).toBeNull(); }); it("filters deployments by the deployed ref", async () => { const { matchRoute } = await import("../server/lib/events/match"); const r: Route = { ...route("r", "g"), filters: [{ type: "branch", match: "main" }] }; for (const name of ["deployment", "deployment_status"]) { expect(matchRoute(r, { event: name, payload: { deployment: { ref: "main" } } })).toBe(true); expect(matchRoute(r, { event: name, payload: { deployment: { ref: "dev" } } })).toBe(false); } }); it("deduplicates group summaries whatever order the targets finished in", async () => { const posts: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (url: unknown) => { posts.push(String(url)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const base: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [], }; const a = { ...route("a", "g"), targets: [{ platform: "discord" as const, channelId: "c1" }], }; const b = { ...route("b", "g"), targets: [{ platform: "discord" as const, channelId: "c2" }], }; const groups: Group[] = [ { id: "g", name: "G", adminIds: [], instance: "i", logTarget: { platform: "discord", channelId: "log" }, }, ]; const event = { event: "push", payload: {}, deliveryId: "d1" }; await dispatchEvent({ ...base, routes: [a, b] }, event, env, groups); await dispatchEvent({ ...base, routes: [b, a] }, event, env, groups); } finally { globalThis.fetch = realFetch; } expect(posts.filter((u) => u.includes("/channels/log/"))).toHaveLength(1); }); }); async function sha256(text: string): Promise { const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)); return [...new Uint8Array(digest)].map((x) => x.toString(16).padStart(2, "0")).join(""); } describe("round 27", () => { it("never lets a late creation bring back a deleted comment's message", async () => { const calls: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { calls.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; const payload = (action: string): Record => ({ action, issue: { number: 7, title: "Bug", html_url: "https://github.com/o/r/issues/7" }, comment: { id: 99, body: "hi", updated_at: "2026-10-01T00:00:00Z", html_url: "https://github.com/o/r/issues/7#issuecomment-99", user: { login: "a" }, }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [{ type: "event", match: "issue_comment" }] }], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; await dispatchEvent( config, { event: "issue_comment", payload: payload("deleted") }, env, groups, ); await dispatchEvent( config, { event: "issue_comment", payload: payload("created") }, env, groups, ); } finally { globalThis.fetch = realFetch; } // The deletion was posted; the creation retried late never edits it back. expect(calls).toEqual(["POST"]); }); it("filters check runs and code scanning alerts by branch name", async () => { const { matchRoute } = await import("../server/lib/events/match"); const r: Route = { ...route("r", "g"), filters: [{ type: "branch", match: "main" }] }; expect( matchRoute(r, { event: "check_run", payload: { check_run: { check_suite: { head_branch: "main" } } }, }), ).toBe(true); expect( matchRoute(r, { event: "code_scanning_alert", payload: { ref: "refs/heads/main" } }), ).toBe(true); expect( matchRoute(r, { event: "code_scanning_alert", payload: { ref: "refs/heads/dev" } }), ).toBe(false); }); it("keeps what a delivery finished as long as its state (7 days)", async () => { const { markTargetsDone } = await import("../server/lib/queue/delivery"); const { db, sqlite } = createSqliteD1(); const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: db }; await markTargetsDone(env, "k", ["t"], { permanentFailure: true }); const rows = sqlite.query("SELECT expires_at FROM dedup_keys").all() as Array<{ expires_at: number; }>; expect(rows).toHaveLength(2); for (const row of rows) expect(row.expires_at).toBeGreaterThan(Date.now() + 6.9 * 86400_000); }); it("scopes logs for many groups with one bound parameter", async () => { const { groupScopeClause } = await import("../server/lib/lib/send-log"); const ids = Array.from({ length: 150 }, (_, i) => `g${i}`); const clause = groupScopeClause(ids)!; expect(clause.args).toHaveLength(1); const { db } = createSqliteD1(); const { getSendLog } = await import("../server/lib/lib/send-log"); await expect(getSendLog(db, 10, ids)).resolves.toEqual([]); }); it("summarizes a retry that skips finished targets as nothing new", async () => { const posts: string[] = []; const realFetch = globalThis.fetch; let failC2 = true; globalThis.fetch = (async (url: unknown) => { const u = String(url); posts.push(u); if (u.includes("/channels/c2/") && failC2) return new Response("{}", { status: 502 }); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [ { ...route("a", "g"), targets: [{ platform: "discord", channelId: "c1" }] }, { ...route("b", "g"), targets: [{ platform: "discord", channelId: "c2" }] }, ], }; const groups: Group[] = [ { id: "g", name: "G", adminIds: [], instance: "i", logTarget: { platform: "discord", channelId: "log" }, }, ]; const done = new Set(); const options = { skipTarget: async (key: string): Promise => done.has(key), afterTarget: async (key: string): Promise => { done.add(key); }, }; const event = { event: "push", payload: {}, deliveryId: "d1" }; await dispatchEvent(config, event, env, groups, options); // The retry skips c1 and fails c2 again: nothing new to report. await dispatchEvent(config, event, env, groups, options); expect(posts.filter((u) => u.includes("/channels/log/"))).toHaveLength(1); // c2 recovers: a new summary. failC2 = false; await dispatchEvent(config, event, env, groups, options); expect(posts.filter((u) => u.includes("/channels/log/"))).toHaveLength(2); // The same id from another forge is another delivery, with its own summary. done.clear(); await dispatchEvent(config, { ...event, provider: "gitea" }, env, groups, options); expect(posts.filter((u) => u.includes("/channels/log/"))).toHaveLength(3); } finally { globalThis.fetch = realFetch; } }, 30_000); }); describe("round 28", () => { async function runChain( payloads: Array<{ event: string; payload: Record }>, groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }], seed?: (sqlite: import("bun:sqlite").Database) => void, ): Promise { const calls: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { calls.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; try { const { db, sqlite } = createSqliteD1(); seed?.(sqlite); const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [] }], }; for (const p of payloads) await dispatchEvent(config, p, env, groups); } finally { globalThis.fetch = realFetch; } return calls; } it("never lets an untimed queued run undo a completion", async () => { const run = (status: string, updated?: string): Record => ({ workflow_run: { id: 5, workflow_id: 9, name: "CI", status, conclusion: status === "completed" ? "success" : null, ...(updated ? { updated_at: updated } : {}), html_url: "https://github.com/o/r/actions/runs/5", }, workflow: { id: 9, name: "CI" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); const calls = await runChain([ { event: "workflow_run", payload: run("completed", "2026-10-01T00:00:00Z") }, { event: "workflow_run", payload: run("queued") }, ]); expect(calls).toEqual(["POST"]); }); it("never lets a late submission undo a dismissed review", async () => { const review = (action: string, state: string): Record => ({ action, review: { id: 3, state, submitted_at: "2026-10-01T00:00:00Z", html_url: "https://github.com/o/r/pull/1#pullrequestreview-3", user: { login: "a" }, }, pull_request: { number: 1, title: "PR", html_url: "https://github.com/o/r/pull/1" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); const calls = await runChain([ { event: "pull_request_review", payload: review("dismissed", "dismissed") }, { event: "pull_request_review", payload: review("submitted", "approved") }, ]); expect(calls).toEqual(["POST"]); }); it("lets exactly one new chain adopt an old message", async () => { const checkRun = (suite: number): Record => ({ action: "completed", check_run: { id: suite, name: "build", head_sha: "abc", status: "completed", conclusion: "success", check_suite: { id: suite }, }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); const calls = await runChain( [ { event: "check_run", payload: checkRun(1) }, { event: "check_run", payload: checkRun(2) }, ], [{ id: "g", name: "G", adminIds: [], instance: "i", legacyId: "g" }], (sqlite) => sqlite.exec( `INSERT INTO message_tracking (event_id, target_id, message_id, updated_at) VALUES ('g:r:check_run:o/r:build:abc', 'c1', 'old-message', 1)`, ), ); expect(calls).toEqual(["PATCH", "POST"]); }); it("takes no old-key lock when there is no old entry to adopt", async () => { const run = { workflow_run: { id: 5, workflow_id: 9, name: "CI", status: "queued", conclusion: null, html_url: "https://github.com/o/r/actions/runs/5", }, workflow: { id: 9, name: "CI" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }; let db: import("bun:sqlite").Database | undefined; const calls = await runChain( [{ event: "workflow_run", payload: run }], [{ id: "g", name: "G", adminIds: [], instance: "i", legacyId: "g" }], (sqlite) => { sqlite.exec("CREATE TABLE lock_log (key TEXT)"); sqlite.exec( `CREATE TRIGGER log_legacy_lock AFTER INSERT ON dedup_keys WHEN NEW.key LIKE 'msg:lock:legacy:%' BEGIN INSERT INTO lock_log VALUES (NEW.key); END`, ); db = sqlite; }, ); expect(calls).toEqual(["POST"]); expect(db!.prepare("SELECT COUNT(*) AS n FROM lock_log").get()).toEqual({ n: 0 }); }); it("lets routes that had no group adopt their unprefixed chains", async () => { const calls = await runChain( [ { event: "check_run", payload: { action: "completed", check_run: { id: 1, name: "build", head_sha: "abc", status: "completed", conclusion: "success", check_suite: { id: 7 }, }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }, }, ], [{ id: "g", name: "G", adminIds: [], instance: "i", legacyId: "" }], (sqlite) => sqlite.exec( `INSERT INTO message_tracking (event_id, target_id, message_id, updated_at) VALUES ('r:check_run:o/r:build:abc', 'c1', 'old-message', 1)`, ), ); expect(calls).toEqual(["PATCH"]); }); it("drops a Feishu token the reply was refused with", async () => { const { forgetRejectedToken, tokenKey } = await import("../server/lib/drivers/feishu/rest"); const { kv } = createMemoryKV(); const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: createSqliteD1().db, FEISHU_APP_ID: "cli_a", }; await kv.put(tokenKey(env), "stale"); await forgetRejectedToken({ ok: false, errorCode: "FEISHU_TOKEN" }, env, "stale"); expect(await kv.get(tokenKey(env))).toBeNull(); }); }); describe("round 29", () => { it("keeps the stage an untimed completion reached over a timed queued state", async () => { const calls: string[] = []; const realFetch = globalThis.fetch; globalThis.fetch = (async (_url: unknown, init?: RequestInit) => { calls.push(String(init?.method)); return new Response(JSON.stringify({ id: "m" }), { status: 200 }); }) as unknown as typeof fetch; const run = (status: string, updated?: string): Record => ({ workflow_run: { id: 5, workflow_id: 9, name: "CI", status, conclusion: status === "completed" ? "success" : null, ...(updated ? { updated_at: updated } : {}), html_url: "https://github.com/o/r/actions/runs/5", }, workflow: { id: 9, name: "CI" }, repository: { full_name: "o/r", html_url: "https://github.com/o/r" }, }); try { const env: Env = { GITHUB_WEBHOOK_SECRET: "", DISCORD_TOKEN: "t", KV: createMemoryKV().kv, DB: createSqliteD1().db, }; const config: Config = { baseUrl: "https://x", github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" }, discord: { token: "t" }, routes: [{ ...route("r", "g"), filters: [] }], }; const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }]; for (const payload of [ run("queued", "2026-10-01T00:00:00Z"), run("completed"), run("queued"), ]) { await dispatchEvent(config, { event: "workflow_run", payload }, env, groups); } } finally { globalThis.fetch = realFetch; } expect(calls).toEqual(["POST", "PATCH"]); }); it("moves an adopted chain entry in one step, leaving nothing behind", async () => { const { messageTracker } = await import("../server/lib/lib/message-tracker"); const { db, sqlite } = createSqliteD1(); const tracker = messageTracker(db, createMemoryKV().kv); await tracker.set("old", "c1", { messageId: "m", version: 1 }); await tracker.move( { eventId: "old", targetId: "c1" }, { eventId: "new", targetId: "d:c1" }, { messageId: "m", version: 1 }, ); expect(await tracker.get("old", "c1")).toBeNull(); expect((await tracker.get("new", "d:c1"))?.messageId).toBe("m"); // A failing move leaves the old entry where it was (one transaction). await tracker.set("old2", "c1", { messageId: "m2", version: 1 }); sqlite.exec( "CREATE TRIGGER no_new BEFORE INSERT ON message_tracking WHEN NEW.event_id = 'new2' BEGIN SELECT RAISE(ABORT, 'boom'); END", ); await expect( tracker.move( { eventId: "old2", targetId: "c1" }, { eventId: "new2", targetId: "d:c1" }, { messageId: "m2", version: 1 }, ), ).rejects.toThrow(); expect((await tracker.get("old2", "c1"))?.messageId).toBe("m2"); }); it("rejects keyword conditions with an operator the matcher would ignore", async () => { const { validateRoutes } = await import("../server/lib/web/admin"); const result = validateRoutes([ { id: "r", name: "r", enabled: true, groupId: "g", filters: [{ type: "keyword", op: "ne", match: "secret" }], targets: [{ platform: "discord", channelId: "1" }], }, ]); expect(result.ok).toBe(false); }); it("caps Discord role mentions", async () => { const { validateRoutes } = await import("../server/lib/web/admin"); const ids = Array.from({ length: 60 }, (_, i) => String(1000000000000000000n + BigInt(i))); const result = validateRoutes([ { id: "r", name: "r", enabled: true, groupId: "g", filters: [], discordRoleIds: ids, targets: [{ platform: "discord", channelId: "1" }], }, ]); expect(result.ok).toBe(false); const { renderNeutralMessage } = await import("../server/lib/drivers/discord/render"); const rendered = renderNeutralMessage({ title: "t", mentionRoleIds: [...ids, ...ids] }); expect((rendered.content ?? "").length).toBeLessThanOrEqual(2000); expect(rendered.allowed_mentions?.roles?.length).toBeLessThanOrEqual(100); }); }); describe("round 30", () => { it("never lets a forge title mention everyone in a Feishu chat", async () => { const { renderNeutralMessage } = await import("../server/lib/drivers/feishu/render"); const card = JSON.stringify( renderNeutralMessage({ title: "o/r#1: hi", url: "https://github.com/o/r/issues/1", description: "", fields: [{ name: "x", value: 'a' }], }), ); expect(/<\/?at\b/i.test(card)).toBe(false); }); it("does not leave HTML tag prefixes in Feishu markdown", async () => { const { renderNeutralMessage } = await import("../server/lib/drivers/feishu/render"); const card = JSON.stringify( renderNeutralMessage({ title: "repo: ", description: "