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: "