// Copyright 2026 The KCP Authors. // SPDX-License-Identifier: Apache-2.0 import { createIngressManager, DROP_AFTER_MS } from "./ingress_manager.js"; function assertEquals(actual, expected) { const a = JSON.stringify(actual); const e = JSON.stringify(expected); if (a !== e) throw new Error(`expected:\n${e}\nactual:\n${a}`); } const flush = () => new Promise((resolve) => setTimeout(resolve, 0)); // harness wires a manager to a fake clock and a fake connect whose promise // and subscriber the test settles by hand. function harness() { let time = 0; let timers = []; const calls = []; const statuses = []; const logs = []; const manager = createIngressManager({ now: () => time, setTimer: (fn, ms) => { const t = { at: time + ms, fn }; timers.push(t); return t; }, clearTimer: (t) => (timers = timers.filter((x) => x !== t)), onStatus: (entries) => statuses.push(entries), log: (level, message) => logs.push(`${level} ${message}`), connect: (entry, hooks) => new Promise((resolve, reject) => { const sub = { connecting: true, closed: 0, close() { this.closed++; } }; calls.push({ entry, hooks, sub, resolve: () => resolve(sub), reject }); }), }); const advance = async (ms) => { const end = time + ms; for (;;) { timers.sort((a, b) => a.at - b.at); const next = timers[0]; if (!next || next.at > end) break; timers.shift(); time = next.at; next.fn(); await flush(); } time = end; }; const state = (host) => manager.status().find((e) => e.host === host)?.state; return { manager, calls, statuses, logs, advance, state, timers: () => timers }; } const entry = (host) => ({ name: `exp-${host}`, host, url: `https://${host}`, did: `did:key:${host}`, proxyHost: "relay" }); Deno.test("single-flight: repeated lists start one subscriber per host", async () => { const h = harness(); h.manager.apply([entry("a")]); h.manager.apply([entry("a")]); h.manager.apply([entry("a"), entry("a")]); assertEquals(h.calls.length, 1); h.calls[0].resolve(); await flush(); h.manager.apply([entry("a")]); assertEquals(h.calls.length, 1); }); Deno.test("status transitions connecting -> registered -> reconnecting -> registered", async () => { const h = harness(); h.manager.apply([entry("a")]); assertEquals(h.state("a"), "connecting"); h.calls[0].resolve(); await flush(); h.calls[0].sub.connecting = false; h.calls[0].hooks.onRegistered({}); assertEquals(h.state("a"), "registered"); h.calls[0].hooks.onClose({ code: 1006, reason: "" }); assertEquals(h.manager.status()[0], { name: "exp-a", host: "a", url: "https://a", state: "reconnecting", lastError: null, closeCode: 1006 }); h.calls[0].hooks.onError(new Error("boom")); assertEquals(h.manager.status()[0].lastError, "boom"); h.calls[0].hooks.onRegistered({}); assertEquals(h.manager.status()[0], { name: "exp-a", host: "a", url: "https://a", state: "registered", lastError: null, closeCode: null }); assertEquals(h.logs.filter((l) => l.startsWith("ok ")), ["ok ingress exp-a registered at https://a", "ok ingress exp-a registered at https://a"]); assertEquals(h.logs.includes("warn ingress exp-a closed: code 1006"), true); assertEquals(h.statuses.map((s) => s[0].state), ["connecting", "registered", "reconnecting", "reconnecting", "registered"]); }); Deno.test("a host missing for less than the drop delay keeps its subscriber", async () => { const h = harness(); h.manager.apply([entry("a")]); h.calls[0].resolve(); await flush(); h.calls[0].sub.connecting = false; h.calls[0].hooks.onRegistered({}); h.manager.apply([]); await h.advance(DROP_AFTER_MS - 1); h.manager.apply([entry("a")]); await h.advance(DROP_AFTER_MS * 2); assertEquals(h.calls[0].sub.closed, 0); assertEquals(h.state("a"), "registered"); assertEquals(h.calls.length, 1); }); Deno.test("a host missing for the drop delay is closed, even without another list", async () => { const h = harness(); h.manager.apply([entry("a"), entry("b")]); for (const c of h.calls) c.resolve(); await flush(); for (const c of h.calls) { c.sub.connecting = false; c.hooks.onRegistered({}); } h.manager.apply([entry("b")]); await h.advance(DROP_AFTER_MS); assertEquals(h.calls[0].sub.closed, 1); assertEquals(h.calls[1].sub.closed, 0); assertEquals(h.statuses.at(-1).map((e) => [e.host, e.state]), [["a", "closed"], ["b", "registered"]]); assertEquals(h.manager.status().map((e) => e.host), ["b"]); // A stopped subscriber's own close event does not revive the entry. h.calls[0].hooks.onClose({ code: 1000, reason: "" }); assertEquals(h.manager.status().map((e) => e.host), ["b"]); // Listed again: a fresh subscriber. h.manager.apply([entry("a"), entry("b")]); assertEquals(h.calls.length, 3); }); Deno.test("a connecting socket is never closed by a list update", async () => { const h = harness(); h.manager.apply([entry("a")]); h.manager.apply([]); // register() still in flight past the drop delay. await h.advance(DROP_AFTER_MS * 3); assertEquals(h.state("a"), "connecting"); h.calls[0].resolve(); await flush(); // Socket created but still CONNECTING. await h.advance(DROP_AFTER_MS); assertEquals(h.calls[0].sub.closed, 0); h.calls[0].sub.connecting = false; h.calls[0].hooks.onRegistered({}); await h.advance(1_000); assertEquals(h.calls[0].sub.closed, 1); assertEquals(h.manager.status(), []); assertEquals(h.calls.length, 1); }); Deno.test("a failed first registration retries with backoff, one timer at a time", async () => { const h = harness(); h.manager.apply([entry("a")]); h.calls[0].reject(new Error("nonce request failed: 502")); await flush(); assertEquals(h.state("a"), "reconnecting"); assertEquals(h.manager.status()[0].lastError, "nonce request failed: 502"); h.manager.apply([entry("a")]); assertEquals(h.timers().length, 1); await h.advance(999); assertEquals(h.calls.length, 1); await h.advance(1); assertEquals(h.calls.length, 2); h.calls[1].reject(new Error("again")); await flush(); await h.advance(1_999); assertEquals(h.calls.length, 2); await h.advance(1); assertEquals(h.calls.length, 3); h.calls[2].resolve(); await flush(); h.calls[2].sub.connecting = false; h.calls[2].hooks.onRegistered({}); assertEquals(h.state("a"), "registered"); assertEquals(h.timers().length, 0); }); Deno.test("retry backoff caps at 30s and a dropped host stops retrying", async () => { const h = harness(); h.manager.apply([entry("a")]); for (let i = 0; i < 7; i++) { h.calls.at(-1).reject(new Error("down")); await flush(); await h.advance(Math.min(1_000 * 2 ** i, 30_000)); assertEquals(h.calls.length, i + 2); } h.calls.at(-1).reject(new Error("down")); await flush(); h.manager.apply([]); await h.advance(DROP_AFTER_MS); assertEquals(h.manager.status(), []); await h.advance(60_000); assertEquals(h.calls.length, 8); }); // End to end against a local fake relay, wired the way kcp_worker.js wires // the manager to ingress_ws.js register. Deno.test("fake relay: register, keepalive 204, request frames, reconnect with fresh tokens", async () => { const { register, frame, parseFrame, KEEPALIVE_PATH } = await import("./ingress_ws.js"); const sockets = []; const authHeaders = []; const subscribeTokens = []; const responses = []; let open = 0; let maxOpen = 0; const server = Deno.serve({ hostname: "127.0.0.1", port: 0, onListen() {} }, (req) => { const url = new URL(req.url); if (url.pathname.endsWith("getRegistrationNonce")) { authHeaders.push(req.headers.get("authorization")); return Response.json({ nonce: btoa("nonce") }); } const { socket, response } = Deno.upgradeWebSocket(req); subscribeTokens.push(url.searchParams.get("service_auth")); socket.onopen = () => { open++; maxOpen = Math.max(maxOpen, open); sockets.push(socket); socket.send(frame("registered", { subdomain: "abc" })); socket.send(frame("request", { requestId: "k", method: "GET", path: KEEPALIVE_PATH })); socket.send(frame("request", { requestId: "b", method: "POST", path: "/xrpc/submitBid", body: { bid: 1 } })); }; socket.onmessage = (e) => responses.push(parseFrame(e.data)); socket.onclose = () => open--; return response; }); const proxyHost = `http://127.0.0.1:${server.addr.port}`; let tokens = 0; const statuses = []; const handled = []; const manager = createIngressManager({ onStatus: (entries) => statuses.push(entries.map((e) => e.state).join(",")), connect: (entry, hooks) => register({ proxyHost: entry.proxyHost, did: entry.did, getServiceAuthToken: async (nsid) => `token-${++tokens}-${nsid.split(".").pop()}`, signer: async (nonce) => nonce, handler: async (req) => { handled.push(req.path); return { status: 200, body: JSON.stringify({ ok: true }), contentType: "application/json" }; }, ...hooks, }), }); const waitFor = async (cond) => { for (let i = 0; i < 400 && !cond(); i++) await new Promise((r) => setTimeout(r, 10)); if (!cond()) throw new Error("timed out"); }; try { const e = { name: "req", host: "h", url: "https://h", did: "did:key:z", proxyHost }; manager.apply([e]); manager.apply([e]); await waitFor(() => responses.length >= 2); assertEquals(manager.status()[0].state, "registered"); assertEquals(responses.find((r) => r.requestId === "k").status, 204); assertEquals(responses.find((r) => r.requestId === "b").status, 200); assertEquals(handled, ["/xrpc/submitBid"]); sockets[0].close(1011, "relay restart"); await waitFor(() => responses.length >= 4); assertEquals(manager.status()[0].state, "registered"); assertEquals(subscribeTokens.length, 2); assertEquals(new Set([...authHeaders, ...subscribeTokens]).size, 4); assertEquals(maxOpen, 1); assertEquals(statuses, ["connecting", "registered", "reconnecting", "registered"]); } finally { manager.apply([]); for (const s of sockets) s.close(); await server.shutdown(); } }); Deno.test("an Exposure not served yet is a quiet wait with a fixed 2s retry", async () => { const h = harness(); h.manager.apply([entry("a")]); for (let i = 0; i < 4; i++) { h.calls.at(-1).reject(new Error('exposure: no ingress Exposure serves "a.example"')); await flush(); assertEquals(h.state("a"), "waiting"); await h.advance(2_000); assertEquals(h.calls.length, i + 2); } h.calls.at(-1).resolve(); await flush(); h.calls.at(-1).sub.connecting = false; h.calls.at(-1).hooks.onRegistered({}); assertEquals(h.state("a"), "registered"); });