mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
* fix(log): preserve structured error details Error objects lose their useful details when serialized as plain JSON. Keep the message, stack and cause in structured log output. * fix(runtime): bound shared in-flight waits A canceled request can leave its shared promise pending forever. Bound joins and coordinate a single replacement so later requests make progress without multiplying upstream work. * fix(bot): reject oversized callback bodies Reject declared oversized bot callbacks before reading their bodies. This keeps unauthenticated requests from wasting worker resources. * test(d1): exercise real sqlite transactions Exercise real foreign keys, transactions and conditional statements instead of mocks that cannot reproduce lost updates or cascades. * fix(storage): preserve claims across kv fallback Only missing tables justify KV fallback; other failures must surface. Remember fallback writes so migration to D1 cannot forget claims and replay completed work. Share marker checks without extra writes. * fix(filter): use isolated linear-time patterns Backtracking patterns can exhaust worker CPU on untrusted payloads. Use linear-time matching and separate bounded cache namespaces so glob and regex entries cannot corrupt each other. * fix(filter): read each event branch correctly Deployment and check branches live in event-specific nested fields. Read those fields and remove only the actual leading ref prefix. * fix(filter): read only own payload properties Inherited object properties are not webhook payload data. Read own properties only so JSONPath cannot traverse prototypes. * fix(filter): validate executable condition trees Malformed trees and unsupported patterns must not silently turn an exclude rule into a pass. Validate the shape and only the patterns the evaluator actually executes. * fix(i18n): bound and cache translation loads Repeated misses and simultaneous override loads spend KV reads for the same language. Cache confirmed misses and share bounded loads without caching read failures as missing translations. * i18n(bot): explain command and account failures Explain account linking, command failures and skipped delivery outcomes consistently in both supported languages. * fix(github): bound and reuse app token fetches Repeated token exchanges waste requests and JWT work for every event. Reuse valid installation tokens, share refreshes and back off briefly after failures while keeping every shared wait bounded. * fix(github): restrict enrichment request urls Webhook-provided URLs must never receive an installation token on another host. Restrict enrichment to GitHub repository API paths, reject redirects and bound optional requests. * fix(formatter): preserve invalid code points Out-of-range numeric entities can throw while formatting a delivery. Keep invalid code points verbatim instead of aborting the message. * fix(formatter): preserve bounded markdown text Code spans, fences, indentation and autolinks are Markdown content, not HTML tags to strip. Preserve them while bounding cleanup input and reusing results across routes for the same event. * fix(formatter): strip only leading ref prefixes A short branch or tag may itself contain refs/heads or refs/tags. Strip one leading full-ref prefix at the caller and keep short names unchanged when generating labels and links. * fix(gitea): link push authors to their forge A Gitea author is not the same-named GitHub account. Build author profile links from the originating forge. * fix(formatter): render deployment state values The deployment status object stringifies as [object Object]. Render its actual state in the status field. * fix(formatter): read security severity levels The scanner severity is not the security severity of an alert. Prefer the security level so critical and high alerts get the right label and color. * fix(formatter): hide actions on other forges Action buttons call the GitHub API as the linked user. Hide them for other forges to avoid operating on a same-named GitHub repository. * fix(check): isolate updates by check suite Same-named checks from different suites must not edit one message. Include the suite or app identity and retain the former key for controlled adoption of existing tracked messages. * fix(logs): scope queries before limiting results Filter authorized groups in SQL before LIMIT and aggregate only visible rows. Preserve current group attribution for late writes, surface read failures and combine related totals in one scan. * perf(d1): index pruning and failed send queries Pruning and failure views should not scan all historical rows. Index the high-value access paths without adding a write-heavy index for infrequent delivery-detail lookups. * fix(discord): bound individual api requests An unbounded API request can outlive an update-chain lock. Bound each request so another holder cannot race a late edit. * fix(discord): defer long rate-limit waits Long rate-limit sleeps block delivery progress inside a worker. Return a retryable 429 for the queue when the wait exceeds the bound. * fix(discord): encode channel path segments Stored channel and message ids are path segments, not URL paths. Encode them so aliases cannot address another Discord resource. * fix(discord): reuse nonces after lost responses A successful create may lose its response. Reuse a stable nonce with enforce_nonce so retries recover that message instead of posting duplicates or accepting an unreadable success. * fix(discord): constrain embeds and role mentions Respect combined embed and component limits as well as field caps. Restrict allowed mentions to validated route roles so payload text cannot notify everyone. * fix(discord): resume bounded command syncs Application changes, command rollbacks and large guild lists can leave commands stale indefinitely. Track the current hash per app and resume bounded paginated work without needless KV writes. * fix(github): verify installation management An installation id is user-controlled, and repository access is not installation management. Verify the owning account or an active organization admin using the user token and read:org scope. * fix(github): resolve immutable member ids A login can be renamed and reclaimed before its first sign-in. Resolve the current immutable user id when membership is granted so a future holder of the login cannot inherit access. * fix(auth): revoke stale sessions and tokens Revoked or rotated credentials must stop working despite stale KV replicas. Track the live token and revocations in D1 and preserve immutable identity bindings rather than trusting a recycled login. * fix(auth): bind sessions and tokens to identity Automatic retries can repeat non-idempotent user actions. Disable those retries and expose a write hook so bot handlers can record completion immediately before the GitHub write. * fix(discord): defer and deduplicate interactions Acknowledge slow actions before Discord times out and deduplicate interaction writes. Preserve comment text and reject edits whose source changed after the modal opened. * fix(telegram): always verify webhook secrets Webhook verification must not silently disable itself when the optional secret is absent. Derive a stable secret from the bot token and reject callbacks when verification is unavailable. * fix(telegram): bound individual api requests Bound individual platform calls so they cannot outlive the lock protecting a message update or stall a whole delivery invocation. * fix(telegram): honor nested rate-limit delays Telegram places retry_after inside parameters, not at the top level. Read that value and defer long waits to the delivery queue. * fix(telegram): report unreadable send results An unreadable successful response may already have sent the message. Report an explicit uncertain result instead of retrying a create without an idempotency key or pretending it succeeded. * fix(telegram): keep editable messages as text Guessing photo versus text from message content makes later edits use the wrong API and a smaller caption budget. Always send text and use the avatar as a link preview. * fix(telegram): render hard breaks as newlines Telegram HTML does not support br tags. Render Markdown hard breaks as plain newlines so otherwise valid messages are accepted. * fix(telegram): clamp visible html characters Telegram counts visible characters, not HTML source bytes. Truncate without splitting tags, entities or surrogate pairs. * fix(telegram): honor the author emoji toggle The author marker must obey the group emoji preference just like formatter-added decoration. * fix(telegram): keep completed commands claimed Redelivery after a completed write must never post another comment. Keep completion claims despite reply failures, scope updates per bot and only issue account-login links in private chats. * fix(feishu): bound individual api requests Bound individual platform calls so they cannot outlive the lock protecting a message update or stall a whole delivery invocation. * fix(feishu): classify retryable api failures Business error codes can be transient even in HTTP 200 responses. Classify token and rate-limit errors for retry and defer long waits. * fix(feishu): retry sends with stable uuids An unreadable response does not prove a send failed. Reuse the same uuid for retries so recovering the result cannot create a second Feishu message. * fix(feishu): refresh and evict tokens safely Separate app token caches, stop reusing refused tokens and share refreshes. Cache failures briefly and keep valid tokens in memory when a best-effort KV cache write fails. * fix(feishu): use the card update endpoint Delayed card updates use the card update endpoint; the config endpoint cannot update an interaction response. * fix(feishu): neutralize untrusted mentions Forge text is untrusted and can contain at-all tags. Neutralize mentions in card bodies and footers before rendering. * fix(feishu): authenticate and dedupe callbacks Authenticate signed or token-verified callbacks before dispatching commands. Decode encrypted envelopes and handle card actions using the correct fields without claiming irrelevant chat events. * fix(target): normalize actual destinations Different target spellings can name the same actual destination. Normalize channel, thread and topic identities for ownership checks and per-route duplicate suppression. * fix(config): transact per-group configuration Whole-table writes and cached snapshots can overwrite other groups or resurrect removed configuration. Use per-group guarded writes, one-time identity migration and explicit unreadable-row failures. * fix(group): preserve identity through lifecycle Group names are mutable and reusable, so they cannot own durable state. Preserve immutable identities across lifecycle operations and commit invite use with membership under transaction-time guards. * fix(oauth): confirm account links and installs A login link or installation id is not proof of account ownership. Verify installation management, bind browser state and require an explicit account-link confirmation before granting chat access. * fix(queue): fence leases and record target outcomes Retries must remember completed targets and distinguish active lease holders. Fence state updates, preserve permanent outcomes and reject missing parked payloads instead of dispatching empty data. * fix(dispatch): isolate and resume tenant sends Check tenant sources before filters and never dispatch orphan routes. Record each target outcome, isolate update chains by forge and group identity, and keep stale events from overwriting newer messages. * fix(queue): bound batches and resume deliveries A queue invocation has shared query and subrequest limits. Use a small batch and shared send budget, renew fenced leases and resume only unfinished work without exhausting unstarted messages. * fix(admin): guard revisions and tenant targets Read-time authorization alone cannot protect concurrent edits. Guard revisions, current roles and destination ownership in the write transaction, and use per-group endpoints for isolated changes. * fix(webhook): confirm only accepted deliveries Acknowledging before queue acceptance permanently loses deliveries. Confirm only accepted work, release failed claims, scope replay identities and strip tenant-supplied installation authority. * fix(storage): prune abandoned parked payloads Oversized payloads can remain after interrupted enqueue attempts. Prune objects beyond their retry lifetime without deleting payloads that a current delivery may still need. * fix(console): expose api conflict statuses Callers need the HTTP status to distinguish stale edits from other failures and reload current data after a conflict. * refactor(console): model group revisions Carry server revisions explicitly so console writes can reject changes based on an outdated group snapshot. * fix(console): send loaded route revisions Send the revision actually loaded with the route list and adopt the server response after a save. Reload on conflict instead of silently overwriting another editor. * fix(console): guard fragment saves by revision Fragments share a group version with other configuration writes. Submit the loaded revision and reload on conflict to preserve concurrent edits. * fix(console): save groups with guarded writes Whole-list saves can overwrite unrelated groups. Use per-group revision-aware writes, retain rename results and confirm deletion on the exact group, routes and version shown to the user. * fix(console): reject edits of stale routes A conflict reload can leave an older route editor open. Compare its original value before saving so it cannot overwrite the newly loaded route. * fix(console): show overview loading failures Failed overview requests must not look like an empty dashboard or a successful refresh. Show the reason while retaining prior data. * fix(console): explain rejected install bindings Explain why an installation binding was refused instead of silently returning to the console with no visible outcome. * fix(console): allow selecting a group named all The all sentinel collides with a valid group id. Use a value that cannot be a group id so that group stays selectable. * fix(console): discard stale log detail responses An older detail request can finish after a newer selection or close. Discard it so the dialog never shows the previously clicked record. * fix(console): retain legacy group owners Groups predating member roles store owners in adminIds. Load those as owners so adding a member never drops all old owners. * fix(console): lock member edits during saves Edits made during a save are overwritten by its result. Disable member controls and guard handlers until the write settles. * fix(console): show invite loading failures Failed invite loads must not look like no pending invites. Show the error and discard responses from a previously shown group. * fix(console): retain legacy discord log targets A stored log target without platform means Discord. Keep that meaning in the editor instead of clearing the target. * fix(console): retain undisplayed forge sources An editor that only displays some providers must preserve the others. Keep stored custom sources when saving unrelated group settings. * fix(console): lock the group editor while saving Prevent edits while a group save is in flight and make super-only installation settings readonly instead of silently ignoring edits. * fix(console): lock route edits and show failures Lock the route editor while saving and show fragment load failures with a retry action rather than presenting a false empty list. * fix(config): expose the legal contact override Declare the public runtime key so the documented environment override reaches legal pages in deployed Nuxt builds. * build(deploy): migrate d1 before deployment Apply pending D1 migrations before deploying code that requires them. Stop deployment when migration fails instead of running against an incomplete schema. * docs(worker): align guides with runtime behavior Synchronize both language guides, API references and examples with the implemented authorization, storage and delivery behavior. Document migration requirements and accepted operational limits. * fix(storage): repair orphaned KV routes Repair orphaned KV routes before serving KV-only configuration. * fix(security): fully escape forge HTML --------- Co-authored-by: RhenCloud <i@rhen.cloud>
3048 lines
116 KiB
TypeScript
3048 lines
116 KiB
TypeScript
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 <br> Telegram rejects", () => {
|
|
const html = renderTelegram({ title: "t", description: "first line \nsecond line" });
|
|
expect(html).not.toContain("<br");
|
|
expect(html).toContain("first line\nsecond line");
|
|
});
|
|
});
|
|
|
|
describe("bot commands", () => {
|
|
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<DeliveryMessage>,
|
|
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<string, unknown> => {
|
|
const payload: Record<string, unknown> = {};
|
|
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<string, unknown> => ({
|
|
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<DeliveryMessage>): Promise<number> => {
|
|
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<DeliveryMessage>,
|
|
{ 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<DeliveryMessage>,
|
|
{ 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<DeliveryMessage>,
|
|
{ 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<DeliveryMessage>,
|
|
{ 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<string, unknown> => ({
|
|
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<string> {
|
|
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<string, unknown> => ({
|
|
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<string>();
|
|
const options = {
|
|
skipTarget: async (key: string): Promise<boolean> => done.has(key),
|
|
afterTarget: async (key: string): Promise<void> => {
|
|
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<string, unknown> }>,
|
|
groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }],
|
|
seed?: (sqlite: import("bun:sqlite").Database) => void,
|
|
): Promise<string[]> {
|
|
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<string, unknown> => ({
|
|
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<string, unknown> => ({
|
|
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<string, unknown> => ({
|
|
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<string, unknown> => ({
|
|
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: <at id=all></at> hi",
|
|
url: "https://github.com/o/r/issues/1",
|
|
description: "<AT id=all></AT>",
|
|
fields: [{ name: "x", value: '<at user_id="ou_1">a</at>' }],
|
|
}),
|
|
);
|
|
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: <script>alert(1)</script>",
|
|
description: "<script>alert(2)",
|
|
footer: "<img src=x>",
|
|
}),
|
|
);
|
|
expect(card).not.toContain("<script");
|
|
expect(card).not.toContain("<img");
|
|
});
|
|
|
|
it("reads a delivery's finished targets in one query", async () => {
|
|
const { markTargetsDone, targetDoneChecker } = await import("../server/lib/queue/delivery");
|
|
const { db } = createSqliteD1();
|
|
let queries = 0;
|
|
const counted = new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "prepare") {
|
|
return (sql: string): D1PreparedStatement => {
|
|
queries++;
|
|
return target.prepare(sql);
|
|
};
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: counted };
|
|
await markTargetsDone(env, "k", ["a", "b"]);
|
|
queries = 0;
|
|
const done = targetDoneChecker(env, "k");
|
|
const results = await Promise.all(["a", "b", "c", "d", "e"].map((t) => done(t)));
|
|
expect(results).toEqual([true, true, false, false, false]);
|
|
expect(queries).toBe(1);
|
|
});
|
|
|
|
it("refuses a route listing the same destination twice, and sends a stored one once", async () => {
|
|
const { validateRoutes } = await import("../server/lib/web/admin");
|
|
const result = validateRoutes([
|
|
{
|
|
id: "r",
|
|
name: "r",
|
|
enabled: true,
|
|
groupId: "g",
|
|
filters: [{ type: "event", match: "push" }],
|
|
targets: [
|
|
{ platform: "telegram", chatId: "-100123" },
|
|
{ platform: "telegram", chatId: "-100123" },
|
|
],
|
|
},
|
|
]);
|
|
expect(result).toMatchObject({ ok: false, error: expect.stringContaining("repeats") });
|
|
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"),
|
|
targets: [
|
|
{ platform: "discord", channelId: "c1" },
|
|
{ platform: "discord", channelId: "c1" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
await dispatchEvent(config, { event: "push", payload: {} }, env, [
|
|
{ id: "g", name: "G", adminIds: [], instance: "i" },
|
|
]);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(posts).toHaveLength(1);
|
|
});
|
|
|
|
it("keeps sign-in redirects on this site", async () => {
|
|
const { safeRedirectPath } = await import("../server/lib/web/oauth");
|
|
expect(safeRedirectPath("/\t/evil.example")).toBe("/");
|
|
expect(safeRedirectPath("/%09/evil.example")).toBe("/%09/evil.example");
|
|
expect(safeRedirectPath("/admin/groups?x=1#y")).toBe("/admin/groups?x=1#y");
|
|
expect(safeRedirectPath("//evil.example")).toBe("/");
|
|
});
|
|
|
|
it("resolves the Discord application per bot token", async () => {
|
|
const { getApplicationId } = await import("../server/lib/drivers/discord/commands");
|
|
const { kv } = createMemoryKV();
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {
|
|
const auth = new Headers(init?.headers).get("authorization") ?? "";
|
|
return new Response(JSON.stringify({ id: auth.endsWith("one") ? "app-1" : "app-2" }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const base = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: createSqliteD1().db };
|
|
expect(await getApplicationId({ ...base, DISCORD_TOKEN: "one" })).toBe("app-1");
|
|
expect(await getApplicationId({ ...base, DISCORD_TOKEN: "two" })).toBe("app-2");
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
});
|
|
|
|
it("gives an auto-provisioned installation group to its audit with its instance", async () => {
|
|
const { ensureInstallationGroup } = await import("../server/lib/web/groups");
|
|
const { kv } = createMemoryKV();
|
|
const group = await ensureInstallationGroup(kv, 42, "acme");
|
|
expect(group?.instance).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("round 31", () => {
|
|
it("filters mentions out of the Feishu note too", async () => {
|
|
const { renderNeutralMessage } = await import("../server/lib/drivers/feishu/render");
|
|
const card = JSON.stringify(
|
|
renderNeutralMessage({
|
|
title: "t",
|
|
footer: "<at id=all></at>",
|
|
forge: { name: "<at id=all>" },
|
|
}),
|
|
);
|
|
expect(/<\/?at\b/i.test(card)).toBe(false);
|
|
});
|
|
|
|
it("caches the Feishu token per app", async () => {
|
|
const { tokenKey } = await import("../server/lib/drivers/feishu/rest");
|
|
const base = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db };
|
|
expect(tokenKey({ ...base, FEISHU_APP_ID: "cli_a" })).not.toBe(
|
|
tokenKey({ ...base, FEISHU_APP_ID: "cli_b" }),
|
|
);
|
|
});
|
|
|
|
it("continues a chain whose message another Discord application sent", async () => {
|
|
const calls: string[] = [];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {
|
|
const method = String(init?.method);
|
|
calls.push(method);
|
|
if (method === "PATCH") {
|
|
return new Response(
|
|
JSON.stringify({
|
|
message: "Cannot edit a message authored by another user",
|
|
code: 50005,
|
|
}),
|
|
{ status: 403 },
|
|
);
|
|
}
|
|
return new Response(JSON.stringify({ id: "m2" }), { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const { db } = createSqliteD1();
|
|
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: "workflow_run" }] }],
|
|
};
|
|
const payload = {
|
|
workflow_run: {
|
|
id: 5,
|
|
workflow_id: 9,
|
|
name: "CI",
|
|
status: "completed",
|
|
conclusion: "success",
|
|
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" },
|
|
};
|
|
const groups: Group[] = [{ id: "g", name: "G", adminIds: [], instance: "i" }];
|
|
// First event posts and tracks a message; then it is "another app's".
|
|
await dispatchEvent(config, { event: "workflow_run", payload }, env, groups);
|
|
|
|
calls.length = 0;
|
|
const later = {
|
|
...payload,
|
|
workflow_run: { ...payload.workflow_run, updated_at: "2026-10-01T00:01:00Z" },
|
|
};
|
|
await dispatchEvent(config, { event: "workflow_run", payload: later }, env, groups);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(calls).toEqual(["PATCH", "POST"]);
|
|
});
|
|
|
|
it("refuses a redirect that dot segments turn protocol-relative", async () => {
|
|
const { safeRedirectPath } = await import("../server/lib/web/oauth");
|
|
expect(safeRedirectPath("/a/..//evil.example")).toBe("/");
|
|
expect(safeRedirectPath("/a/%2e%2e//evil.example")).toBe("/");
|
|
});
|
|
|
|
it("refuses a Discord thread listed alone and with its parent", async () => {
|
|
const { validateRoutes } = await import("../server/lib/web/admin");
|
|
const result = validateRoutes([
|
|
{
|
|
id: "r",
|
|
name: "r",
|
|
enabled: true,
|
|
groupId: "g",
|
|
filters: [{ type: "event", match: "push" }],
|
|
targets: [
|
|
{ platform: "discord", channelId: "222" },
|
|
{ platform: "discord", channelId: "111", threadId: "222" },
|
|
],
|
|
},
|
|
]);
|
|
expect(result).toMatchObject({ ok: false, error: expect.stringContaining("repeats") });
|
|
});
|
|
|
|
it("registers the commands again after a rollback", async () => {
|
|
const { registerGlobalCommands } = await import("../server/lib/drivers/discord/commands");
|
|
const { kv } = createMemoryKV();
|
|
// A marker left by other command definitions (a newer version, rolled back).
|
|
await kv.put("cmd:registered:global:app", "other-definitions");
|
|
let puts = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
puts++;
|
|
return new Response("[]", { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
await registerGlobalCommands({
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
DB: createSqliteD1().db,
|
|
DISCORD_TOKEN: "t",
|
|
DISCORD_APPLICATION_ID: "app",
|
|
});
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(puts).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("round 32", () => {
|
|
it("accepts Telegram topic ids written one way only", async () => {
|
|
const { validateRoutes } = await import("../server/lib/web/admin");
|
|
const routeWith = (topicId: string): unknown => ({
|
|
id: "r",
|
|
name: "r",
|
|
enabled: true,
|
|
groupId: "g",
|
|
filters: [{ type: "event", match: "push" }],
|
|
targets: [{ platform: "telegram", chatId: "-100123", topicId }],
|
|
});
|
|
expect(validateRoutes([routeWith("12")]).ok).toBe(true);
|
|
for (const bad of ["01", "1e0", "abc", "-1", "99999999999"]) {
|
|
expect(validateRoutes([routeWith(bad)]).ok).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("pages through every guild when syncing commands", async () => {
|
|
const { syncGuildCommands } = await import("../server/lib/drivers/discord/commands");
|
|
const realFetch = globalThis.fetch;
|
|
const registered: string[] = [];
|
|
globalThis.fetch = (async (input: unknown, init?: RequestInit) => {
|
|
const url = new URL(String(input));
|
|
if (url.pathname.endsWith("/users/@me/guilds")) {
|
|
const after = Number(url.searchParams.get("after") ?? "0");
|
|
const size = Number(url.searchParams.get("limit"));
|
|
const ids = Array.from({ length: 250 }, (_, i) => i + 1).filter((i) => i > after);
|
|
return new Response(JSON.stringify(ids.slice(0, size).map((id) => ({ id: String(id) }))), {
|
|
status: 200,
|
|
});
|
|
}
|
|
if (init?.method === "PUT") registered.push(url.pathname);
|
|
return new Response("[]", { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
const env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
DISCORD_TOKEN: "t",
|
|
DISCORD_APPLICATION_ID: "app",
|
|
};
|
|
try {
|
|
// Each run registers a bounded share; the record carries the progress on.
|
|
for (let run = 0; run < 12; run++) await syncGuildCommands(env);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(new Set(registered).size).toBe(250);
|
|
expect(registered).toHaveLength(250);
|
|
});
|
|
|
|
it("gives a link confirmation back when the link could not be written", async () => {
|
|
const { handleLinkConfirm } = await import("../server/lib/web/oauth");
|
|
const { makeEvent } = await import("./helpers");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
const nonce = "a".repeat(32);
|
|
await kv.put(
|
|
`link:${nonce}`,
|
|
JSON.stringify({ platform: "telegram", userId: "5", githubUserId: "7", login: "alice" }),
|
|
);
|
|
let fail = true;
|
|
const flaky = new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "prepare") {
|
|
return (sql: string): D1PreparedStatement => {
|
|
if (fail && sql.includes("telegram_links")) throw new Error("D1 down");
|
|
return target.prepare(sql);
|
|
};
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: flaky };
|
|
const submit = (): ReturnType<typeof makeEvent> =>
|
|
makeEvent("/auth/github/link", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: JSON.stringify({ nonce }),
|
|
env,
|
|
});
|
|
await expect(handleLinkConfirm(submit())).rejects.toThrow();
|
|
fail = false;
|
|
const page = await handleLinkConfirm(submit());
|
|
expect(page).not.toContain("链接已失效");
|
|
const row = await db
|
|
.prepare("SELECT github_user_id FROM telegram_links WHERE telegram_user_id = '5'")
|
|
.first<{ github_user_id: string }>();
|
|
expect(row?.github_user_id).toBe("7");
|
|
});
|
|
});
|
|
|
|
describe("round 33", () => {
|
|
/** A D1 whose batches commit, then answer with an error (a lost answer). */
|
|
function lostAnswers(db: D1Database): D1Database {
|
|
return new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "batch") {
|
|
return async (statements: D1PreparedStatement[]): Promise<never> => {
|
|
await target.batch(statements);
|
|
throw new Error("connection reset");
|
|
};
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
}
|
|
|
|
it("never lets a link confirmation whose answer was lost be replayed", async () => {
|
|
const { handleLinkConfirm } = await import("../server/lib/web/oauth");
|
|
const { makeEvent } = await import("./helpers");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
const nonce = "b".repeat(32);
|
|
await kv.put(
|
|
`link:${nonce}`,
|
|
JSON.stringify({ platform: "telegram", userId: "5", githubUserId: "A", login: "a" }),
|
|
);
|
|
const submit = (DB: D1Database): ReturnType<typeof makeEvent> =>
|
|
makeEvent("/auth/github/link", {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: JSON.stringify({ nonce }),
|
|
env: { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB },
|
|
});
|
|
// Committed, answer lost: still a success.
|
|
expect(await handleLinkConfirm(submit(lostAnswers(db)))).not.toContain("链接已失效");
|
|
// Linked to B since; replaying the old confirmation changes nothing.
|
|
await db
|
|
.prepare(
|
|
"INSERT OR REPLACE INTO telegram_links (telegram_user_id, github_user_id) VALUES ('5', 'B')",
|
|
)
|
|
.run();
|
|
await kv.put(
|
|
`link:${nonce}`,
|
|
JSON.stringify({ platform: "telegram", userId: "5", githubUserId: "A", login: "a" }),
|
|
);
|
|
expect(await handleLinkConfirm(submit(db))).toContain("链接已失效");
|
|
const row = await db
|
|
.prepare("SELECT github_user_id FROM telegram_links WHERE telegram_user_id = '5'")
|
|
.first<{ github_user_id: string }>();
|
|
expect(row?.github_user_id).toBe("B");
|
|
});
|
|
|
|
it("treats an unlink whose answer was lost as done", async () => {
|
|
const { unlinkAsCommand } = await import("../server/lib/github/store");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
await db
|
|
.prepare("INSERT INTO telegram_links (telegram_user_id, github_user_id) VALUES ('5', 'A')")
|
|
.run();
|
|
await unlinkAsCommand({ DB: lostAnswers(db), KV: kv }, "telegram", "5", {
|
|
key: "accepted:bot:telegram:x:1",
|
|
ttl: 600,
|
|
});
|
|
const { idempotencyStore } = await import("../server/lib/lib/idempotency");
|
|
expect(await idempotencyStore(db, kv).has("accepted:bot:telegram:x:1")).toBe(true);
|
|
});
|
|
|
|
it("reads no configuration for a request without a session", async () => {
|
|
const { loadAuth } = await import("../server/lib/web/auth");
|
|
const { makeEvent } = await import("./helpers");
|
|
let reads = 0;
|
|
const { db } = createSqliteD1();
|
|
const counted = new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "prepare") {
|
|
return (sql: string): D1PreparedStatement => {
|
|
if (sql.includes("d1_groups") || sql.includes("d1_routes")) reads++;
|
|
return target.prepare(sql);
|
|
};
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: counted };
|
|
expect(await loadAuth(makeEvent("/admin/api/groups", { env }))).toBeNull();
|
|
expect(reads).toBe(0);
|
|
});
|
|
|
|
it("sends once to one Telegram topic written two ways", async () => {
|
|
const posts: string[] = [];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (url: unknown) => {
|
|
posts.push(String(url));
|
|
return new Response(JSON.stringify({ ok: true, result: { message_id: 1 } }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
TELEGRAM_TOKEN: "t",
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
};
|
|
const config: Config = {
|
|
baseUrl: "https://x",
|
|
github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" },
|
|
discord: { token: "" },
|
|
routes: [
|
|
{
|
|
...route("r", "g"),
|
|
targets: [
|
|
{ platform: "telegram", chatId: "-100123", topicId: "1" },
|
|
{ platform: "telegram", chatId: "-100123", topicId: "01" },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
await dispatchEvent(config, { event: "push", payload: {} }, env, [
|
|
{ id: "g", name: "G", adminIds: [], instance: "i" },
|
|
]);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(posts.filter((u) => u.includes("/sendMessage"))).toHaveLength(1);
|
|
});
|
|
|
|
it("counts Telegram's limit on the text shown, not the HTML source", async () => {
|
|
const { renderNeutralMessage } = await import("../server/lib/drivers/telegram/render");
|
|
const html = renderNeutralMessage({ title: "t", description: "&".repeat(2000) });
|
|
expect(html).toContain("&".repeat(2000));
|
|
const long = renderNeutralMessage({ title: "t", description: "&".repeat(5000) });
|
|
expect(long.endsWith("…") || long.includes("…<")).toBe(true);
|
|
expect(long).not.toMatch(/&a?m?p?…/);
|
|
});
|
|
|
|
it("shows a code scanning alert's security severity", async () => {
|
|
const { formatEvent } = await import("../server/lib/formatters");
|
|
const message = formatEvent(route("r", "g"), {
|
|
event: "code_scanning_alert",
|
|
payload: {
|
|
action: "created",
|
|
alert: {
|
|
rule: { id: "x", severity: "error", security_severity_level: "critical" },
|
|
state: "open",
|
|
},
|
|
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
|
},
|
|
});
|
|
expect(JSON.stringify(message)).toContain("critical");
|
|
});
|
|
});
|
|
|
|
describe("round 34", () => {
|
|
it("never lets a run that outlived its claim unlink a link made since", async () => {
|
|
const { unlinkAsCommand } = await import("../server/lib/github/store");
|
|
const { idempotencyStore } = await import("../server/lib/lib/idempotency");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
// Another run finished the logout; the user linked again.
|
|
await idempotencyStore(db, kv).claim("accepted:bot:telegram:x:9", 600);
|
|
await db
|
|
.prepare("INSERT INTO telegram_links (telegram_user_id, github_user_id) VALUES ('5', 'new')")
|
|
.run();
|
|
await unlinkAsCommand({ DB: db, KV: kv }, "telegram", "5", {
|
|
key: "accepted:bot:telegram:x:9",
|
|
ttl: 600,
|
|
});
|
|
const row = await db
|
|
.prepare("SELECT github_user_id FROM telegram_links WHERE telegram_user_id = '5'")
|
|
.first<{ github_user_id: string }>();
|
|
expect(row?.github_user_id).toBe("new");
|
|
});
|
|
|
|
it("keeps Markdown code that looks like HTML", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
expect(htmlToText("Repro: `<MyComponent />` fails.<br>")).toBe(
|
|
"Repro: `<MyComponent />` fails.",
|
|
);
|
|
expect(htmlToText("```\n<T>&\n```")).toBe("```\n<T>&\n```");
|
|
});
|
|
|
|
it("links a Gitea commit author on the Gitea host", async () => {
|
|
const { formatEvent } = await import("../server/lib/formatters");
|
|
const message = formatEvent(route("r", "g"), {
|
|
event: "push",
|
|
provider: "gitea",
|
|
payload: {
|
|
ref: "refs/heads/main",
|
|
pusher: { login: "bob", username: "bob" },
|
|
sender: { login: "bob" },
|
|
repository: { full_name: "o/r", html_url: "https://git.example/o/r" },
|
|
commits: [{ id: "abcdef1234567", message: "fix", author: { username: "alice" } }],
|
|
},
|
|
});
|
|
const text = JSON.stringify(message);
|
|
expect(text).toContain("https://git.example/alice");
|
|
expect(text).not.toContain("https://github.com/alice");
|
|
});
|
|
});
|
|
|
|
describe("round 35", () => {
|
|
it("keeps more Markdown code forms and autolinks", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
expect(htmlToText("Use ``<Widget />`` here")).toBe("Use ``<Widget />`` here");
|
|
expect(htmlToText('~~~\nconst x = "<tag>";\n~~~')).toBe('~~~\nconst x = "<tag>";\n~~~');
|
|
expect(htmlToText("See <https://example.com/build>")).toBe("See <https://example.com/build>");
|
|
expect(htmlToText("a<br>b <b>c</b>")).toBe("a\nb c");
|
|
});
|
|
|
|
it("refuses an exists condition whose match could not be read back", async () => {
|
|
const { validateRoutes } = await import("../server/lib/web/admin");
|
|
const withMatch = (match: unknown): unknown => ({
|
|
id: "r",
|
|
name: "r",
|
|
enabled: true,
|
|
groupId: "g",
|
|
filters: [{ type: "field", path: "action", op: "exists", match }],
|
|
targets: [{ platform: "discord", channelId: "1" }],
|
|
});
|
|
expect(validateRoutes([withMatch(null)]).ok).toBe(false);
|
|
expect(validateRoutes([withMatch({ a: 1 })]).ok).toBe(false);
|
|
const { match: _m, ...noMatch } = (
|
|
withMatch(undefined) as { filters: Array<Record<string, unknown>> }
|
|
).filters[0]!;
|
|
expect(validateRoutes([{ ...(withMatch(undefined) as object), filters: [noMatch] }]).ok).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("binds the matching groups an earlier attempt left unbound", async () => {
|
|
const { ensureInstallationGroup } = await import("../server/lib/web/groups");
|
|
const { createGroup, loadGroups } = await import("../server/lib/web/groups");
|
|
const { kv } = createMemoryKV();
|
|
await createGroup(kv, {
|
|
id: "a",
|
|
name: "a",
|
|
adminIds: [],
|
|
owners: ["acme"],
|
|
installationId: 7,
|
|
});
|
|
await createGroup(kv, { id: "b", name: "b", adminIds: [], owners: ["acme"] });
|
|
await ensureInstallationGroup(kv, 7, "acme");
|
|
const b = (await loadGroups(kv, { fresh: true })).find((g) => g.id === "b");
|
|
expect(b?.installationId).toBe(7);
|
|
});
|
|
});
|
|
|
|
describe("round 36", () => {
|
|
it("keeps Markdown code whose delimiters vary in length", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
expect(htmlToText("``a ` <T>``")).toBe("``a ` <T>``");
|
|
expect(htmlToText("````\n```\n<a>\n```\n````")).toBe("````\n```\n<a>\n```\n````");
|
|
expect(htmlToText("`multi\n<line>` code")).toBe("`multi\n<line>` code");
|
|
expect(htmlToText("lone ` tick <i>y</i>")).toBe("lone ` tick y");
|
|
});
|
|
|
|
it("never lets a stale KV copy of a moved chain entry be adopted again", async () => {
|
|
const { messageTracker } = await import("../server/lib/lib/message-tracker");
|
|
const { noteKvFallback } = await import("../server/lib/storage/d1");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
await noteKvFallback(kv);
|
|
// The old entry lives in KV (written while the table was missing).
|
|
await kv.put("msg:old:c1", JSON.stringify({ id: "m", v: 1 }));
|
|
const tracker = messageTracker(db, kv);
|
|
await tracker.move(
|
|
{ eventId: "old", targetId: "c1" },
|
|
{ eventId: "new", targetId: "d:c1" },
|
|
{ messageId: "m", version: 1 },
|
|
);
|
|
// Another location still sees the KV copy (its delete not there yet).
|
|
await kv.put("msg:old:c1", JSON.stringify({ id: "m", v: 1 }));
|
|
expect(await tracker.get("old", "c1")).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("round 37", () => {
|
|
it("keeps progressing through guilds within each run's call budget", async () => {
|
|
const { syncGuildCommands } = await import("../server/lib/drivers/discord/commands");
|
|
const realFetch = globalThis.fetch;
|
|
const registered: string[] = [];
|
|
let callsThisRun = 0;
|
|
globalThis.fetch = (async (input: unknown, init?: RequestInit) => {
|
|
callsThisRun++;
|
|
const url = new URL(String(input));
|
|
if (url.pathname.endsWith("/users/@me/guilds")) {
|
|
const after = Number(url.searchParams.get("after") ?? "0");
|
|
const ids = Array.from({ length: 2000 }, (_, i) => i + 1).filter((i) => i > after);
|
|
return new Response(JSON.stringify(ids.slice(0, 200).map((id) => ({ id: String(id) }))), {
|
|
status: 200,
|
|
});
|
|
}
|
|
if (init?.method === "PUT") registered.push(url.pathname);
|
|
return new Response("[]", { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
const env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
DISCORD_TOKEN: "t",
|
|
DISCORD_APPLICATION_ID: "app",
|
|
};
|
|
try {
|
|
for (let run = 0; run < 3; run++) {
|
|
callsThisRun = 0;
|
|
await syncGuildCommands(env);
|
|
expect(callsThisRun).toBeLessThanOrEqual(30);
|
|
}
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
// Each run made progress from where the last one stopped.
|
|
expect(new Set(registered).size).toBe(registered.length);
|
|
expect(registered.length).toBeGreaterThan(80);
|
|
});
|
|
|
|
it("never provisions an installation again after its claim lapsed", async () => {
|
|
const { processWebhook } = await import("../server/lib/webhook");
|
|
const { resetConfigStore } = await import("../server/lib/config");
|
|
const { loadGroups, updateGroup } = await import("../server/lib/web/groups");
|
|
const { createHmac } = await import("crypto");
|
|
const { db, sqlite } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
resetConfigStore(kv);
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "global",
|
|
KV: kv,
|
|
DB: db,
|
|
QUEUE: { send: async () => undefined } as unknown as Queue,
|
|
};
|
|
const body = JSON.stringify({
|
|
action: "created",
|
|
installation: { id: 321, account: { login: "acme" } },
|
|
});
|
|
const headers = {
|
|
"x-github-event": "installation",
|
|
"x-github-delivery": "inst-late",
|
|
"x-hub-signature-256": `sha256=${createHmac("sha256", "global").update(body).digest("hex")}`,
|
|
};
|
|
expect((await processWebhook(env, body, headers, () => undefined)).status).toBe(200);
|
|
await updateGroup(kv, "inst-321", (g) => ({ ...g, installationId: undefined }));
|
|
// The ingress dedup claim and its confirmation lapse (minutes later).
|
|
sqlite.exec(
|
|
"DELETE FROM dedup_keys WHERE key LIKE 'delivery:%' OR key LIKE 'accepted:delivery:%'",
|
|
);
|
|
expect((await processWebhook(env, body, headers, () => undefined)).status).toBe(200);
|
|
const group = (await loadGroups(kv, { fresh: true })).find((g) => g.id === "inst-321");
|
|
expect(group?.installationId).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("round 37 markdown", () => {
|
|
it("closes fences with their own character, keeps indented code and e-mail links", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
expect(htmlToText("~~~~\n<T>\n~~~~`\n<U>\n~~~~")).toBe("~~~~\n<T>\n~~~~`\n<U>\n~~~~");
|
|
expect(htmlToText("text\n\n <MyComponent />")).toBe("text\n\n <MyComponent />");
|
|
expect(htmlToText("mail <dev@example.com> now")).toBe("mail <dev@example.com> now");
|
|
});
|
|
});
|
|
|
|
describe("round 38", () => {
|
|
it("looks up a failed check suite's build log once per dispatch", async () => {
|
|
const keys = (await crypto.subtle.generateKey(
|
|
{
|
|
name: "RSASSA-PKCS1-v1_5",
|
|
modulusLength: 2048,
|
|
publicExponent: new Uint8Array([1, 0, 1]),
|
|
hash: "SHA-256",
|
|
},
|
|
true,
|
|
["sign", "verify"],
|
|
)) as CryptoKeyPair;
|
|
const pkcs8 = Buffer.from(await crypto.subtle.exportKey("pkcs8", keys.privateKey)).toString(
|
|
"base64",
|
|
);
|
|
const pem = `-----BEGIN PRIVATE KEY-----\n${pkcs8.match(/.{1,64}/g)!.join("\n")}\n-----END PRIVATE KEY-----`;
|
|
let githubCalls = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (input: unknown) => {
|
|
const url = String(input);
|
|
if (url.includes("api.github.com")) {
|
|
githubCalls++;
|
|
if (url.includes("access_tokens")) {
|
|
return new Response(JSON.stringify({ token: "inst" }), { status: 201 });
|
|
}
|
|
return new Response(JSON.stringify({ check_runs: [] }), { status: 200 });
|
|
}
|
|
return new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
DISCORD_TOKEN: "t",
|
|
GITHUB_APP_ID: "1",
|
|
GITHUB_PRIVATE_KEY: pem,
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
};
|
|
const config: Config = {
|
|
baseUrl: "https://x",
|
|
github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" },
|
|
discord: { token: "t" },
|
|
routes: ["a", "b", "c"].map((id) => ({
|
|
...route(id, "g"),
|
|
filters: [{ type: "event" as const, match: "check_suite" }],
|
|
targets: [{ platform: "discord" as const, channelId: id }],
|
|
})),
|
|
};
|
|
await dispatchEvent(
|
|
config,
|
|
{
|
|
event: "check_suite",
|
|
installationId: 5,
|
|
payload: {
|
|
action: "completed",
|
|
check_suite: {
|
|
id: 1,
|
|
conclusion: "failure",
|
|
check_runs_url: "https://api.github.com/repos/o/r/check-suites/1/check-runs",
|
|
},
|
|
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
|
},
|
|
},
|
|
env,
|
|
[{ id: "g", name: "G", adminIds: [], instance: "i" }],
|
|
);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
// One token and one check list for the three routes.
|
|
expect(githubCalls).toBe(2);
|
|
});
|
|
|
|
it("cleans a body full of unclosed brackets in linear time", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
const started = performance.now();
|
|
htmlToText(("<" + "x".repeat(30)).repeat(8000));
|
|
expect(performance.now() - started).toBeLessThan(500);
|
|
});
|
|
|
|
it("keeps the indent of code that opens the body", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
expect(htmlToText(" <T>\n <U>")).toBe(" <T>\n <U>");
|
|
expect(htmlToText(" hi <b>x</b> ")).toBe("hi x");
|
|
});
|
|
|
|
it("never binds again a group an earlier provisioning bound", async () => {
|
|
const { ensureInstallationGroup, createGroup, loadGroups, updateGroup } =
|
|
await import("../server/lib/web/groups");
|
|
const { resetConfigStore, initConfigStore } = await import("../server/lib/config");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
resetConfigStore(kv);
|
|
initConfigStore({ GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db });
|
|
await createGroup(kv, { id: "team", name: "team", adminIds: [], owners: ["acme"] });
|
|
await ensureInstallationGroup(kv, 77, "acme", db);
|
|
expect(
|
|
(await loadGroups(kv, { fresh: true })).find((g) => g.id === "team")?.installationId,
|
|
).toBe(77);
|
|
// An admin unbinds it; provisioning runs again (a retry of a failed attempt).
|
|
await updateGroup(kv, "team", (g) => ({ ...g, installationId: undefined }));
|
|
await ensureInstallationGroup(kv, 77, "acme", db);
|
|
expect(
|
|
(await loadGroups(kv, { fresh: true })).find((g) => g.id === "team")?.installationId,
|
|
).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("round 39", () => {
|
|
it("strips only the leading refs/ prefix of a branch or tag", async () => {
|
|
const { branchLink, refUrl, shortRef } = await import("../server/lib/formatters/helpers");
|
|
expect(shortRef("refs/heads/feature/refs/tags/test")).toBe("feature/refs/tags/test");
|
|
expect(shortRef("refs/tags/v1/refs/tags/x")).toBe("v1/refs/tags/x");
|
|
// Short names are taken as written (a branch may be called `refs/heads/x`).
|
|
expect(refUrl("https://g/o/r", "refs/heads/release", "branch")).toBe(
|
|
"https://g/o/r/tree/refs/heads/release",
|
|
);
|
|
expect(branchLink("https://g/o/r", "feature/refs/heads/test")).toContain(
|
|
"/tree/feature/refs/heads/test",
|
|
);
|
|
});
|
|
|
|
it("never binds a group that another attempt bound after this one checked", async () => {
|
|
const { ensureInstallationGroup, createGroup, loadGroups } =
|
|
await import("../server/lib/web/groups");
|
|
const { resetConfigStore, initConfigStore } = await import("../server/lib/config");
|
|
const { db, sqlite } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
resetConfigStore(kv);
|
|
initConfigStore({ GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db });
|
|
await createGroup(kv, { id: "team", name: "team", adminIds: [], owners: ["acme"] });
|
|
const team = (await loadGroups(kv, { fresh: true })).find((g) => g.id === "team")!;
|
|
// This attempt's check sees no record; the record lands before its write
|
|
// (another attempt bound the group and an admin unbound it meanwhile).
|
|
const late = new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "prepare") {
|
|
return (sql: string): D1PreparedStatement => {
|
|
if (sql.includes("SELECT 1 AS hit FROM dedup_keys")) {
|
|
sqlite.exec(
|
|
`INSERT OR REPLACE INTO dedup_keys (key, claimed_at, expires_at) VALUES ('installation-bound:88:${team.instance}', 0, ${Date.now() + 86400_000})`,
|
|
);
|
|
return target.prepare("SELECT 1 AS hit WHERE 0");
|
|
}
|
|
return target.prepare(sql);
|
|
};
|
|
}
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
await ensureInstallationGroup(kv, 88, "acme", late);
|
|
const after = (await loadGroups(kv, { fresh: true })).find((g) => g.id === "team");
|
|
expect(after?.installationId).toBeUndefined();
|
|
});
|
|
|
|
it("cleans one body once for many routes", async () => {
|
|
const { htmlToText } = await import("../server/lib/formatters/helpers");
|
|
const body = Array.from({ length: 140 }, (_, i) => "`".repeat(i + 1) + "x")
|
|
.join(" ")
|
|
.slice(0, 10000);
|
|
const started = performance.now();
|
|
for (let i = 0; i < 50; i++) htmlToText(body);
|
|
expect(performance.now() - started).toBeLessThan(200);
|
|
});
|
|
});
|
|
|
|
describe("round 40", () => {
|
|
it("remembers a missing fallback marker for a while (one KV read, not one per claim)", async () => {
|
|
const { kvFallbackActive } = await import("../server/lib/storage/d1");
|
|
const { kv } = createMemoryKV();
|
|
let reads = 0;
|
|
const get = kv.get.bind(kv);
|
|
kv.get = ((...args: unknown[]) => {
|
|
reads++;
|
|
return (get as (...a: unknown[]) => unknown)(...args);
|
|
}) as KVNamespace["get"];
|
|
for (let i = 0; i < 20; i++) expect(await kvFallbackActive(kv)).toBe(false);
|
|
expect(reads).toBe(1);
|
|
});
|
|
|
|
it("checks a seen fallback marker again later, so an expired one stops the KV lookups", async () => {
|
|
const { kvFallbackActive, noteKvFallback } = await import("../server/lib/storage/d1");
|
|
const { kv } = createMemoryKV();
|
|
await noteKvFallback(kv);
|
|
expect(await kvFallbackActive(kv)).toBe(true);
|
|
// The marker expires in KV; an hour on, this isolate reads it again.
|
|
await kv.delete("storage:kv-fallback");
|
|
const realNow = Date.now;
|
|
Date.now = (): number => realNow() + 2 * 3600_000;
|
|
try {
|
|
expect(await kvFallbackActive(kv)).toBe(false);
|
|
} finally {
|
|
Date.now = realNow;
|
|
}
|
|
});
|
|
|
|
it("keeps a refs/heads/ path inside a tag name out of the branch filter", async () => {
|
|
const { matchRoute } = await import("../server/lib/events/match");
|
|
const r: Route = {
|
|
...route("r", "g"),
|
|
filters: [{ type: "branch", match: "refs/tags/release/main" }],
|
|
};
|
|
expect(
|
|
matchRoute(r, { event: "push", payload: { ref: "refs/tags/release/refs/heads/main" } }),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("names a newly pushed branch as it is", async () => {
|
|
const { formatEvent } = await import("../server/lib/formatters");
|
|
const text = JSON.stringify(
|
|
formatEvent(route("r", "g"), {
|
|
event: "push",
|
|
payload: {
|
|
ref: "refs/heads/feature/refs/tags/test",
|
|
created: true,
|
|
commits: [],
|
|
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
|
sender: { login: "a" },
|
|
},
|
|
}),
|
|
);
|
|
expect(text).toContain("feature/refs/tags/test");
|
|
expect(text).toContain("/tree/feature/refs/tags/test");
|
|
});
|
|
|
|
it("logs an error's message and stack", async () => {
|
|
const { log } = await import("../server/lib/lib/log");
|
|
const lines: string[] = [];
|
|
const real = console.error;
|
|
console.error = (line: string): void => void lines.push(line);
|
|
try {
|
|
log.error({ requestId: "r", err: new Error("D1: database is locked") }, "Write failed");
|
|
} finally {
|
|
console.error = real;
|
|
}
|
|
const entry = JSON.parse(lines[0]!) as {
|
|
msg: string;
|
|
requestId: string;
|
|
err: { message: string };
|
|
};
|
|
expect(entry.msg).toBe("Write failed");
|
|
expect(entry.requestId).toBe("r");
|
|
expect(entry.err.message).toBe("D1: database is locked");
|
|
});
|
|
});
|
|
|
|
describe("round 41", () => {
|
|
it("never takes a branch named refs/tags/… for a tag", async () => {
|
|
const { formatEvent } = await import("../server/lib/formatters");
|
|
const text = JSON.stringify(
|
|
formatEvent(route("r", "g"), {
|
|
event: "push",
|
|
payload: {
|
|
ref: "refs/heads/refs/tags/release",
|
|
commits: [{ id: "abcdef1234567", message: "fix", author: { username: "a" } }],
|
|
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
|
sender: { login: "a" },
|
|
pusher: { name: "a" },
|
|
},
|
|
}),
|
|
);
|
|
expect(text).not.toContain("tag: release");
|
|
expect(text).toContain("refs/tags/release");
|
|
});
|
|
});
|
|
|
|
describe("quota", () => {
|
|
it("writes nothing when a guild command sync finds nothing to do", async () => {
|
|
const { syncGuildCommands } = await import("../server/lib/drivers/discord/commands");
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (input: unknown) => {
|
|
const url = String(input);
|
|
if (url.includes("/users/@me/guilds")) {
|
|
return new Response(JSON.stringify([{ id: "1" }]), { status: 200 });
|
|
}
|
|
return new Response("[]", { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
const { kv } = createMemoryKV();
|
|
const env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
DB: createSqliteD1().db,
|
|
DISCORD_TOKEN: "t",
|
|
DISCORD_APPLICATION_ID: "app",
|
|
};
|
|
try {
|
|
await syncGuildCommands(env);
|
|
let writes = 0;
|
|
const put = kv.put.bind(kv);
|
|
kv.put = ((...args: unknown[]) => {
|
|
writes++;
|
|
return (put as (...a: unknown[]) => unknown)(...args);
|
|
}) as KVNamespace["put"];
|
|
await syncGuildCommands(env);
|
|
await syncGuildCommands(env);
|
|
expect(writes).toBe(0);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("round 42", () => {
|
|
it("keeps a KV-only chain entry when its move to D1 fails", async () => {
|
|
const { messageTracker } = await import("../server/lib/lib/message-tracker");
|
|
const { noteKvFallback } = await import("../server/lib/storage/d1");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
await noteKvFallback(kv);
|
|
await kv.put("msg:old:c1", JSON.stringify({ id: "m", v: 1 }));
|
|
const failing = new Proxy(db, {
|
|
get(target, prop, receiver): unknown {
|
|
if (prop === "batch")
|
|
return async (): Promise<never> => Promise.reject(new Error("D1 down"));
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
}) as D1Database;
|
|
const tracker = messageTracker(failing, kv);
|
|
await expect(
|
|
tracker.move(
|
|
{ eventId: "old", targetId: "c1" },
|
|
{ eventId: "new", targetId: "d:c1" },
|
|
{ messageId: "m", version: 1 },
|
|
),
|
|
).rejects.toThrow();
|
|
expect((await tracker.get("old", "c1"))?.messageId).toBe("m");
|
|
});
|
|
});
|
|
|
|
describe("round 43", () => {
|
|
it("reaches the guilds after a page whose registrations kept failing", async () => {
|
|
const { syncGuildCommands } = await import("../server/lib/drivers/discord/commands");
|
|
const realFetch = globalThis.fetch;
|
|
const put: string[] = [];
|
|
globalThis.fetch = (async (input: unknown, _init?: RequestInit) => {
|
|
const url = new URL(String(input));
|
|
if (url.pathname.endsWith("/users/@me/guilds")) {
|
|
const after = Number(url.searchParams.get("after") ?? "0");
|
|
const ids = Array.from({ length: 201 }, (_, i) => i + 1).filter((i) => i > after);
|
|
return new Response(JSON.stringify(ids.slice(0, 200).map((id) => ({ id: String(id) }))), {
|
|
status: 200,
|
|
});
|
|
}
|
|
const guild = Number(url.pathname.split("/guilds/")[1]?.split("/")[0]);
|
|
put.push(String(guild));
|
|
return new Response("[]", { status: guild >= 172 && guild <= 200 ? 500 : 200 });
|
|
}) as unknown as typeof fetch;
|
|
const env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
DISCORD_TOKEN: "t",
|
|
DISCORD_APPLICATION_ID: "app",
|
|
};
|
|
try {
|
|
for (let run = 0; run < 12; run++) await syncGuildCommands(env);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(put).toContain("201");
|
|
});
|
|
});
|
|
|
|
describe("quota review 1", () => {
|
|
it("fetches and stores one Feishu token for parallel sends", async () => {
|
|
const { getTenantAccessToken } = await import("../server/lib/drivers/feishu/rest");
|
|
const { kv } = createMemoryKV();
|
|
let fetches = 0;
|
|
let writes = 0;
|
|
const put = kv.put.bind(kv);
|
|
kv.put = ((...args: unknown[]) => {
|
|
writes++;
|
|
return (put as (...a: unknown[]) => unknown)(...args);
|
|
}) as KVNamespace["put"];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
fetches++;
|
|
return new Response(JSON.stringify({ code: 0, tenant_access_token: "t", expire: 7200 }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
DB: createSqliteD1().db,
|
|
FEISHU_APP_ID: "cli_quota",
|
|
FEISHU_APP_SECRET: "s",
|
|
};
|
|
const results = await Promise.all(Array.from({ length: 5 }, () => getTenantAccessToken(env)));
|
|
expect(results.every((r) => r.token === "t")).toBe(true);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(fetches).toBe(1);
|
|
expect(writes).toBe(1);
|
|
});
|
|
|
|
it("registers an unchanged Telegram webhook once, not on every cron run", async () => {
|
|
const { syncTelegramWebhook } = await import("../server/lib/drivers/telegram/commands");
|
|
let calls = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
calls++;
|
|
return new Response(JSON.stringify({ ok: true }), { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: createMemoryKV().kv,
|
|
DB: createSqliteD1().db,
|
|
TELEGRAM_TOKEN: "1:x",
|
|
BASE_URL: "https://hooks.example",
|
|
};
|
|
try {
|
|
for (let i = 0; i < 3; i++) await syncTelegramWebhook(env);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(calls).toBe(1);
|
|
});
|
|
|
|
it("does not read KV again for a language without an override", async () => {
|
|
const { loadTranslations } = await import("../server/lib/lib/i18n");
|
|
let reads = 0;
|
|
const kv = {
|
|
get: async (): Promise<null> => {
|
|
reads++;
|
|
return null;
|
|
},
|
|
};
|
|
for (let i = 0; i < 5; i++) await loadTranslations("xx-quota", kv);
|
|
expect(reads).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("quota review 5", () => {
|
|
const feishuEnv = (kv: KVNamespace, appId: string): Env => ({
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
DB: createSqliteD1().db,
|
|
FEISHU_APP_ID: appId,
|
|
FEISHU_APP_SECRET: "s",
|
|
});
|
|
|
|
it("answers targets after a failed Feishu token request from memory for a moment", async () => {
|
|
const { getTenantAccessToken } = await import("../server/lib/drivers/feishu/rest");
|
|
const { kv } = createMemoryKV();
|
|
let fetches = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
fetches++;
|
|
return new Response(JSON.stringify({ code: 99991663, msg: "app ticket invalid" }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const env = feishuEnv(kv, "cli_fail_cache");
|
|
for (let i = 0; i < 5; i++) expect((await getTenantAccessToken(env)).ok).toBe(false);
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(fetches).toBe(1);
|
|
});
|
|
|
|
it("keeps a Feishu token in KV only while a held copy would still be valid", async () => {
|
|
const { getTenantAccessToken, tokenKey } = await import("../server/lib/drivers/feishu/rest");
|
|
const { kv } = createMemoryKV();
|
|
const ttls: number[] = [];
|
|
const put = kv.put.bind(kv);
|
|
kv.put = ((key: string, value: string, opts?: { expirationTtl?: number }) => {
|
|
ttls.push(opts?.expirationTtl ?? 0);
|
|
return put(key, value, opts);
|
|
}) as KVNamespace["put"];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () =>
|
|
new Response(JSON.stringify({ code: 0, tenant_access_token: "t", expire: 7200 }), {
|
|
status: 200,
|
|
})) as unknown as typeof fetch;
|
|
try {
|
|
const env = feishuEnv(kv, "cli_ttl");
|
|
expect((await getTenantAccessToken(env)).token).toBe("t");
|
|
expect(await kv.get(tokenKey(env))).toBe("t");
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
// 7200 s token: out of KV 60 s + one hold (300 s) before it expires.
|
|
expect(ttls).toEqual([7200 - 60 - 300]);
|
|
});
|
|
|
|
it("drops a rejected Feishu token once, and never a newer one", async () => {
|
|
const { forgetRejectedToken, tokenKey } = await import("../server/lib/drivers/feishu/rest");
|
|
const { kv } = createMemoryKV();
|
|
const env = feishuEnv(kv, "cli_forget");
|
|
let deletes = 0;
|
|
const del = kv.delete.bind(kv);
|
|
kv.delete = ((key: string) => {
|
|
deletes++;
|
|
return del(key);
|
|
}) as KVNamespace["delete"];
|
|
await kv.put(tokenKey(env), "old");
|
|
const refused = { ok: false, errorCode: "FEISHU_TOKEN" };
|
|
for (let i = 0; i < 5; i++) await forgetRejectedToken(refused, env, "old");
|
|
expect(deletes).toBe(1);
|
|
// A late refusal of an older token leaves the token stored since alone.
|
|
await kv.put(tokenKey(env), "new");
|
|
await forgetRejectedToken(refused, env, "older");
|
|
expect(await kv.get(tokenKey(env))).toBe("new");
|
|
});
|
|
|
|
it("serves recent failures and a group's audit log from indexes", () => {
|
|
const { sqlite } = createSqliteD1();
|
|
const plan = (sql: string): string =>
|
|
(sqlite.prepare(`EXPLAIN QUERY PLAN ${sql}`).all() as Array<{ detail: string }>)
|
|
.map((r) => r.detail)
|
|
.join("; ");
|
|
expect(plan("SELECT id FROM send_logs WHERE ok = 0 ORDER BY ts DESC LIMIT 20")).toContain(
|
|
"idx_send_logs_failed_ts",
|
|
);
|
|
expect(
|
|
plan("SELECT id FROM send_logs WHERE ok = 0 AND group_id = 'g' ORDER BY ts DESC LIMIT 20"),
|
|
).toContain("idx_send_logs_failed_group_ts");
|
|
const audit = plan("SELECT id FROM audit_logs WHERE group_id = 'g' ORDER BY ts DESC LIMIT 50");
|
|
expect(audit).toContain("idx_audit_group_ts");
|
|
expect(audit).not.toContain("TEMP B-TREE");
|
|
});
|
|
});
|
|
|
|
describe("quota review 6", () => {
|
|
it("shares one fallback marker read among concurrent checks", async () => {
|
|
const { kvFallbackActive } = await import("../server/lib/storage/d1");
|
|
const { kv } = createMemoryKV();
|
|
let reads = 0;
|
|
const get = kv.get.bind(kv);
|
|
kv.get = ((...args: unknown[]) => {
|
|
reads++;
|
|
return (get as (...a: unknown[]) => unknown)(...args);
|
|
}) as KVNamespace["get"];
|
|
const results = await Promise.all(Array.from({ length: 20 }, () => kvFallbackActive(kv)));
|
|
expect(results.every((r) => r === false)).toBe(true);
|
|
expect(reads).toBe(1);
|
|
});
|
|
|
|
it("runs a cold store's setup once for concurrent requests", async () => {
|
|
const { initConfigStore, loadConfigSnapshot } = await import("../server/lib/config");
|
|
const { db } = createSqliteD1();
|
|
const { kv } = createMemoryKV();
|
|
let seedReads = 0;
|
|
const get = kv.get.bind(kv);
|
|
kv.get = ((key: string, ...rest: unknown[]) => {
|
|
if (key === "config:d1-seeded") seedReads++;
|
|
return (get as (...a: unknown[]) => unknown)(key, ...rest);
|
|
}) as KVNamespace["get"];
|
|
const env: Env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: db };
|
|
initConfigStore(env);
|
|
await Promise.all(Array.from({ length: 20 }, () => loadConfigSnapshot(env, { fresh: true })));
|
|
expect(seedReads).toBe(1);
|
|
});
|
|
|
|
it("holds a Feishu token it could not share in KV until it nears expiry", async () => {
|
|
const { getTenantAccessToken } = await import("../server/lib/drivers/feishu/rest");
|
|
const { kv } = createMemoryKV();
|
|
kv.put = (async () => {
|
|
throw new Error("KV put() limit exceeded for the day");
|
|
}) as KVNamespace["put"];
|
|
let fetches = 0;
|
|
const realFetch = globalThis.fetch;
|
|
const realNow = Date.now;
|
|
globalThis.fetch = (async () => {
|
|
fetches++;
|
|
return new Response(JSON.stringify({ code: 0, tenant_access_token: "t", expire: 7200 }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
const env: Env = {
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
DB: createSqliteD1().db,
|
|
FEISHU_APP_ID: "cli_no_kv",
|
|
FEISHU_APP_SECRET: "s",
|
|
};
|
|
expect((await getTenantAccessToken(env)).token).toBe("t");
|
|
// An hour on (well past the usual few minutes in memory): still held.
|
|
Date.now = (): number => realNow() + 3600_000;
|
|
expect((await getTenantAccessToken(env)).token).toBe("t");
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
Date.now = realNow;
|
|
}
|
|
expect(fetches).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("quota review 7 (partial)", () => {
|
|
it("writes the fallback marker once for concurrent fallbacks", async () => {
|
|
const { noteKvFallback } = await import("../server/lib/storage/d1");
|
|
const { kv } = createMemoryKV();
|
|
let writes = 0;
|
|
const put = kv.put.bind(kv);
|
|
kv.put = ((...args: Parameters<KVNamespace["put"]>) => {
|
|
writes++;
|
|
return put(...args);
|
|
}) as KVNamespace["put"];
|
|
await Promise.all(Array.from({ length: 20 }, () => noteKvFallback(kv)));
|
|
expect(writes).toBe(1);
|
|
});
|
|
|
|
it("reads a language override once for concurrent asks", async () => {
|
|
const { loadTranslations } = await import("../server/lib/lib/i18n");
|
|
let reads = 0;
|
|
const kv = {
|
|
get: async <T>(): Promise<T | null> => {
|
|
reads++;
|
|
return null;
|
|
},
|
|
};
|
|
await Promise.all(Array.from({ length: 20 }, () => loadTranslations("xx-concurrent", kv)));
|
|
expect(reads).toBe(1);
|
|
});
|
|
|
|
it("does not ask GitHub again right after an installation token exchange failed", async () => {
|
|
const { getInstallationToken } = await import("../server/lib/github/app-token");
|
|
const { generateKeyPairSync } = await import("node:crypto");
|
|
const { privateKey } = generateKeyPairSync("rsa", { modulusLength: 2048 });
|
|
const pem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
|
|
let requests = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
requests++;
|
|
return new Response("{}", { status: 500 });
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
for (let i = 0; i < 3; i++) {
|
|
expect(await getInstallationToken("1", pem, 777001)).toBeUndefined();
|
|
}
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(requests).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("round 52", () => {
|
|
it("never waits on another request's run past its limit", async () => {
|
|
const { sharedFlight } = await import("../server/lib/lib/shared-flight");
|
|
const flights = new Map<string, { promise: Promise<string>; startedAt: number }>();
|
|
// A run whose request was canceled: it never settles, its cleanup never runs.
|
|
flights.set("k", { promise: new Promise<string>(() => {}), startedAt: Date.now() });
|
|
const started = performance.now();
|
|
expect(await sharedFlight(flights, "k", async () => "own", 30)).toBe("own");
|
|
expect(performance.now() - started).toBeLessThan(1000);
|
|
// A run that old is not joined at all.
|
|
flights.set("k", { promise: new Promise<string>(() => {}), startedAt: Date.now() - 60 });
|
|
expect(await sharedFlight(flights, "k", async () => "fresh", 30)).toBe("fresh");
|
|
expect(flights.has("k")).toBe(false);
|
|
});
|
|
|
|
it("replaces a stuck run once for all its waiters", async () => {
|
|
const { sharedFlight } = await import("../server/lib/lib/shared-flight");
|
|
const flights = new Map<string, { promise: Promise<string>; startedAt: number }>();
|
|
flights.set("k", { promise: new Promise<string>(() => {}), startedAt: Date.now() });
|
|
let runs = 0;
|
|
const run = async (): Promise<string> => {
|
|
runs++;
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
return "replaced";
|
|
};
|
|
const results = await Promise.all(
|
|
Array.from({ length: 10 }, () => sharedFlight(flights, "k", run, 30)),
|
|
);
|
|
expect(results.every((r) => r === "replaced")).toBe(true);
|
|
expect(runs).toBe(1);
|
|
});
|
|
|
|
it("lets every waiter of a stuck run take a replacement that already finished", async () => {
|
|
const { sharedFlight } = await import("../server/lib/lib/shared-flight");
|
|
const flights = new Map<string, { promise: Promise<string>; startedAt: number }>();
|
|
flights.set("k", { promise: new Promise<string>(() => {}), startedAt: Date.now() });
|
|
let runs = 0;
|
|
// Finishes (and leaves the map) before the other waiters wake up.
|
|
const run = async (): Promise<string> => {
|
|
runs++;
|
|
return "replaced";
|
|
};
|
|
const results = await Promise.all(
|
|
Array.from({ length: 10 }, () => sharedFlight(flights, "k", run, 30)),
|
|
);
|
|
expect(results.every((r) => r === "replaced")).toBe(true);
|
|
expect(runs).toBe(1);
|
|
});
|
|
|
|
it("runs alone, unpublished, after finding three runs stuck", async () => {
|
|
const { sharedFlight } = await import("../server/lib/lib/shared-flight");
|
|
type F = { promise: Promise<string>; startedAt: number; replacedBy?: F };
|
|
const stuck = (): F => ({ promise: new Promise<string>(() => {}), startedAt: Date.now() });
|
|
const first = stuck();
|
|
first.replacedBy = stuck();
|
|
first.replacedBy.replacedBy = stuck();
|
|
const flights = new Map<string, F>([["k", first]]);
|
|
expect(await sharedFlight(flights, "k", async () => "alone", 20)).toBe("alone");
|
|
expect(flights.get("k")).toBe(first);
|
|
});
|
|
|
|
it("shares a run that is still in time", async () => {
|
|
const { sharedFlight } = await import("../server/lib/lib/shared-flight");
|
|
const flights = new Map<string, { promise: Promise<number>; startedAt: number }>();
|
|
let runs = 0;
|
|
const run = async (): Promise<number> => {
|
|
runs++;
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
return runs;
|
|
};
|
|
const results = await Promise.all(
|
|
Array.from({ length: 5 }, () => sharedFlight(flights, "k", run, 1000)),
|
|
);
|
|
expect(results).toEqual([1, 1, 1, 1, 1]);
|
|
expect(runs).toBe(1);
|
|
});
|
|
|
|
it("does not take a refused Feishu token back from KV when deleting it failed", async () => {
|
|
const { forgetRejectedToken, getTenantAccessToken, 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_refused",
|
|
FEISHU_APP_SECRET: "s",
|
|
};
|
|
await kv.put(tokenKey(env), "refused");
|
|
const del = kv.delete.bind(kv);
|
|
kv.delete = (async () => {
|
|
throw new Error("KV delete failed");
|
|
}) as KVNamespace["delete"];
|
|
await forgetRejectedToken({ ok: false, errorCode: "FEISHU_TOKEN" }, env, "refused");
|
|
kv.delete = del;
|
|
let fetches = 0;
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async () => {
|
|
fetches++;
|
|
return new Response(JSON.stringify({ code: 0, tenant_access_token: "new", expire: 7200 }), {
|
|
status: 200,
|
|
});
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
expect((await getTenantAccessToken(env)).token).toBe("new");
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(fetches).toBe(1);
|
|
});
|
|
|
|
it("registers a Telegram webhook switched back to an earlier setting again", async () => {
|
|
const { syncTelegramWebhook } = await import("../server/lib/drivers/telegram/commands");
|
|
const { kv } = createMemoryKV();
|
|
const urls: string[] = [];
|
|
const realFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {
|
|
urls.push(String(JSON.parse(String(init?.body)).url));
|
|
return new Response(JSON.stringify({ ok: true }), { status: 200 });
|
|
}) as unknown as typeof fetch;
|
|
try {
|
|
for (const base of ["https://a.example", "https://b.example", "https://a.example"]) {
|
|
await syncTelegramWebhook({
|
|
GITHUB_WEBHOOK_SECRET: "",
|
|
KV: kv,
|
|
TELEGRAM_TOKEN: "77:switch",
|
|
BASE_URL: base,
|
|
});
|
|
}
|
|
} finally {
|
|
globalThis.fetch = realFetch;
|
|
}
|
|
expect(urls).toEqual([
|
|
"https://a.example/telegram/webhook",
|
|
"https://b.example/telegram/webhook",
|
|
"https://a.example/telegram/webhook",
|
|
]);
|
|
});
|
|
});
|