|
8 | 8 | } from "./live"; |
9 | 9 | import { keypair, message, roster, signed, scriptedTransport } from "./testing"; |
10 | 10 | import { createRelaySession } from "./session"; |
| 11 | +import { createPresence } from "../presence/presence"; |
11 | 12 | type WireFilter = { |
12 | 13 | kinds: number[]; |
13 | 14 | "#h"?: string[]; |
@@ -1438,56 +1439,77 @@ it("presence holds its receipt without delaying ordinary setup and shares correl |
1438 | 1439 | h.owner.dispose(); |
1439 | 1440 | }); |
1440 | 1441 |
|
1441 | | -it("an outstanding presence signer pins its principal flight across socket replacement", async () => { |
1442 | | - vi.useFakeTimers(); |
1443 | | - const key = keypair(), |
1444 | | - sockets: Socket[] = []; |
1445 | | - const admission = createLiveAdmission(); |
1446 | | - let release!: () => void; |
1447 | | - const gate = new Promise<void>((resolve) => { |
1448 | | - release = resolve; |
1449 | | - }); |
1450 | | - const callbacks = { receive() {}, state() {}, established() {}, denied() {} }; |
1451 | | - const owner = subscribeRelayTraffic( |
1452 | | - "wss://relay.test", |
1453 | | - async (event) => { |
1454 | | - if (event.kind === 20001) await gate; |
1455 | | - return signed(key, event); |
1456 | | - }, |
1457 | | - key.pubkey, |
1458 | | - callbacks, |
1459 | | - () => { |
1460 | | - const s = new Socket(); |
1461 | | - sockets.push(s); |
1462 | | - return s as unknown as WebSocket; |
1463 | | - }, |
1464 | | - admission, |
1465 | | - ); |
1466 | | - const first = sockets[0]; |
1467 | | - assert.exists(first); |
1468 | | - await first.auth(); |
1469 | | - await vi.advanceTimersByTimeAsync(500); |
1470 | | - for (const [, id] of first.requests()) await first.receive(["EOSE", id]); |
1471 | | - const result = owner.publishPresence?.("away", new AbortController().signal); |
1472 | | - expect(admission.presenceIdle()).toBe(false); |
1473 | | - first.close(); |
1474 | | - await vi.advanceTimersByTimeAsync(500); |
1475 | | - const next = sockets[1]; |
1476 | | - assert.exists(next); |
1477 | | - await next.auth(); |
1478 | | - await vi.advanceTimersByTimeAsync(500); |
1479 | | - for (const [, id] of next.requests()) await next.receive(["EOSE", id]); |
1480 | | - expect( |
1481 | | - await owner.publishPresence?.("online", new AbortController().signal), |
1482 | | - ).toEqual({ retryAfterMs: 250 }); |
1483 | | - release(); |
1484 | | - expect(await result).toBeNull(); |
1485 | | - expect( |
1486 | | - sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"), |
1487 | | - ).toEqual([]); |
1488 | | - expect(admission.presenceIdle()).toBe(true); |
1489 | | - owner.dispose(); |
1490 | | -}); |
| 1442 | +it.each(["reconnect", "cooldown"])( |
| 1443 | + "an outstanding presence signer respects %s", |
| 1444 | + async (mode) => { |
| 1445 | + vi.useFakeTimers(); |
| 1446 | + const key = keypair(), |
| 1447 | + sockets: Socket[] = []; |
| 1448 | + const admission = createLiveAdmission(); |
| 1449 | + let release!: () => void; |
| 1450 | + const gate = new Promise<void>((resolve) => { |
| 1451 | + release = resolve; |
| 1452 | + }); |
| 1453 | + const callbacks = { |
| 1454 | + receive() {}, |
| 1455 | + state() {}, |
| 1456 | + established() {}, |
| 1457 | + denied() {}, |
| 1458 | + }; |
| 1459 | + const owner = subscribeRelayTraffic( |
| 1460 | + "wss://relay.test", |
| 1461 | + async (event) => { |
| 1462 | + if (event.kind === 20001) await gate; |
| 1463 | + return signed(key, event); |
| 1464 | + }, |
| 1465 | + key.pubkey, |
| 1466 | + callbacks, |
| 1467 | + () => { |
| 1468 | + const s = new Socket(); |
| 1469 | + sockets.push(s); |
| 1470 | + return s as unknown as WebSocket; |
| 1471 | + }, |
| 1472 | + admission, |
| 1473 | + ); |
| 1474 | + const first = sockets[0]; |
| 1475 | + assert.exists(first); |
| 1476 | + await first.auth(); |
| 1477 | + await vi.advanceTimersByTimeAsync(500); |
| 1478 | + for (const [, id] of first.requests()) await first.receive(["EOSE", id]); |
| 1479 | + const result = owner.publishPresence?.( |
| 1480 | + "away", |
| 1481 | + new AbortController().signal, |
| 1482 | + ); |
| 1483 | + expect(admission.presenceIdle()).toBe(false); |
| 1484 | + if (mode === "reconnect") { |
| 1485 | + first.close(); |
| 1486 | + await vi.advanceTimersByTimeAsync(500); |
| 1487 | + const next = sockets[1]; |
| 1488 | + assert.exists(next); |
| 1489 | + await next.auth(); |
| 1490 | + await vi.advanceTimersByTimeAsync(500); |
| 1491 | + for (const [, id] of next.requests()) await next.receive(["EOSE", id]); |
| 1492 | + expect( |
| 1493 | + await owner.publishPresence?.("online", new AbortController().signal), |
| 1494 | + ).toBeNull(); |
| 1495 | + } else { |
| 1496 | + admission.pause(3); |
| 1497 | + // A real cooldown wins even when another flight is busy signing. |
| 1498 | + expect( |
| 1499 | + await owner.publishPresence?.("online", new AbortController().signal), |
| 1500 | + ).toEqual({ retryAfterMs: 4000 }); |
| 1501 | + } |
| 1502 | + release(); |
| 1503 | + expect(await result).toEqual( |
| 1504 | + mode === "reconnect" ? null : { retryAfterMs: 4000 }, |
| 1505 | + ); |
| 1506 | + expect( |
| 1507 | + sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"), |
| 1508 | + ).toEqual([]); |
| 1509 | + expect(admission.presenceIdle()).toBe(true); |
| 1510 | + owner.dispose(); |
| 1511 | + }, |
| 1512 | +); |
1491 | 1513 |
|
1492 | 1514 | it("admits signed typing only on its authenticated channel route, without extra subscriptions", async () => { |
1493 | 1515 | vi.useFakeTimers(); |
@@ -2049,12 +2071,132 @@ it("presence shares the authenticated socket, verifies signatures, and replaces |
2049 | 2071 | h.owner.dispose(); |
2050 | 2072 | }); |
2051 | 2073 |
|
| 2074 | +it.each([false, true])( |
| 2075 | + "paces replacement commands behind a held receipt without polling (late cooldown: %s)", |
| 2076 | + async (cooldown) => { |
| 2077 | + vi.useFakeTimers(); |
| 2078 | + vi.spyOn(Math, "random").mockReturnValue(0); |
| 2079 | + vi.stubGlobal("navigator", { |
| 2080 | + locks: { |
| 2081 | + request: async ( |
| 2082 | + _name: string, |
| 2083 | + _options: unknown, |
| 2084 | + work: () => Promise<void>, |
| 2085 | + ) => work(), |
| 2086 | + }, |
| 2087 | + }); |
| 2088 | + const h = setup([]); |
| 2089 | + const listeners = new Set<() => void>(); |
| 2090 | + let status: "online" | "away" | "offline" = "online", |
| 2091 | + command = 0; |
| 2092 | + const attempts: number[] = []; |
| 2093 | + const publishPresence = h.owner.publishPresence; |
| 2094 | + assert.exists(publishPresence); |
| 2095 | + const publish = vi.fn( |
| 2096 | + (value: "online" | "away" | "offline", signal: AbortSignal) => { |
| 2097 | + attempts.push(performance.now()); |
| 2098 | + return publishPresence(value, signal); |
| 2099 | + }, |
| 2100 | + ); |
| 2101 | + const owner = createPresence( |
| 2102 | + { |
| 2103 | + ...scriptedTransport(h.key.pubkey, h.key.pubkey).transport, |
| 2104 | + viewer: h.key.pubkey, |
| 2105 | + presenceSnapshot: async () => new Map([[h.key.pubkey, "online"]]), |
| 2106 | + }, |
| 2107 | + { |
| 2108 | + visible: () => true, |
| 2109 | + status: () => status, |
| 2110 | + command: () => command, |
| 2111 | + subscribe(fn) { |
| 2112 | + listeners.add(fn); |
| 2113 | + return () => { |
| 2114 | + listeners.delete(fn); |
| 2115 | + }; |
| 2116 | + }, |
| 2117 | + dispose() {}, |
| 2118 | + }, |
| 2119 | + publish, |
| 2120 | + (fn) => fn(), |
| 2121 | + ); |
| 2122 | + const events = () => |
| 2123 | + h.first.sent |
| 2124 | + .filter(([kind]) => kind === "EVENT") |
| 2125 | + .map(([, event]) => event as { id: string; content: string }); |
| 2126 | + try { |
| 2127 | + await h.first.auth(); |
| 2128 | + owner.subscribe(h.key.pubkey, () => {}); |
| 2129 | + owner.connected(true); |
| 2130 | + await vi.advanceTimersByTimeAsync(250); |
| 2131 | + for (const request of h.first.requests()) |
| 2132 | + await h.first.receive(["EOSE", request[1]]); |
| 2133 | + expect(events().map((event) => event.content)).toEqual(["online"]); |
| 2134 | + await vi.advanceTimersByTimeAsync(1000); |
| 2135 | + status = "away"; |
| 2136 | + command++; |
| 2137 | + for (const fn of listeners) fn(); |
| 2138 | + await vi.advanceTimersByTimeAsync(4050); |
| 2139 | + // The gate opened, but the original receipt still owns the flight. |
| 2140 | + expect(attempts).toEqual([250, 1250, 5300]); |
| 2141 | + expect(await publish.mock.results[2]?.value).toBeNull(); |
| 2142 | + await vi.advanceTimersByTimeAsync(700); |
| 2143 | + status = "offline"; |
| 2144 | + command++; |
| 2145 | + for (const fn of listeners) fn(); |
| 2146 | + await vi.advanceTimersByTimeAsync(4000); |
| 2147 | + expect(attempts).toEqual([250, 1250, 5300, 6000]); |
| 2148 | + expect(events()).toHaveLength(1); |
| 2149 | + const first = events()[0]; |
| 2150 | + assert.exists(first); |
| 2151 | + // Aborting the old owner must not discard a late shared quota refusal. |
| 2152 | + await h.first.receive([ |
| 2153 | + "OK", |
| 2154 | + first.id, |
| 2155 | + !cooldown, |
| 2156 | + cooldown ? "rate-limited: quota exceeded; retry in 1s" : "", |
| 2157 | + ]); |
| 2158 | + await vi.advanceTimersByTimeAsync(999); |
| 2159 | + expect(attempts).toEqual([250, 1250, 5300, 6000]); |
| 2160 | + await vi.advanceTimersByTimeAsync(1); |
| 2161 | + if (cooldown) { |
| 2162 | + expect(events()).toHaveLength(1); |
| 2163 | + await vi.advanceTimersByTimeAsync(1049); |
| 2164 | + expect(attempts).toEqual([250, 1250, 5300, 6000, 11000]); |
| 2165 | + await vi.advanceTimersByTimeAsync(1); |
| 2166 | + } |
| 2167 | + expect(attempts).toEqual( |
| 2168 | + cooldown |
| 2169 | + ? [250, 1250, 5300, 6000, 11000, 12050] |
| 2170 | + : [250, 1250, 5300, 6000, 11000], |
| 2171 | + ); |
| 2172 | + expect(events().map((event) => event.content)).toEqual([ |
| 2173 | + "online", |
| 2174 | + "offline", |
| 2175 | + ]); |
| 2176 | + expect(owner.status(h.key.pubkey)).toBe("online"); |
| 2177 | + const last = events().at(-1); |
| 2178 | + assert.exists(last); |
| 2179 | + await h.first.receive(["OK", last.id, true, ""]); |
| 2180 | + await vi.advanceTimersByTimeAsync(0); |
| 2181 | + expect(owner.status(h.key.pubkey)).toBe("offline"); |
| 2182 | + const count = attempts.length; |
| 2183 | + await vi.advanceTimersByTimeAsync(65000); |
| 2184 | + expect(attempts).toHaveLength(count); // No superseded renewal or Offline lease. |
| 2185 | + } finally { |
| 2186 | + owner.dispose(); |
| 2187 | + h.owner.dispose(); |
| 2188 | + vi.restoreAllMocks(); |
| 2189 | + vi.unstubAllGlobals(); |
| 2190 | + } |
| 2191 | + }, |
| 2192 | +); |
| 2193 | + |
2052 | 2194 | it("reports the remaining presence gate without extending it and honors cooldown", () => { |
2053 | 2195 | vi.useFakeTimers(); |
2054 | 2196 | const admission = createLiveAdmission(); |
2055 | 2197 | expect(admission.presenceDelay()).toBe(0); |
2056 | 2198 | const release = admission.tryPresence(); |
2057 | | - expect(admission.presenceDelay()).toBe(250); |
| 2199 | + expect(admission.presenceDelay()).toBe(0); |
2058 | 2200 | admission.presenceSent(); |
2059 | 2201 | vi.advanceTimersByTime(1200); |
2060 | 2202 | expect(admission.presenceDelay()).toBe(3800); |
|
0 commit comments