retry-send.spec.ts (16267B)
1 import { test, expect } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { once } from 'node:events'; 5 import { WebSocketServer } from 'ws'; 6 import { createStaticHarness } from '../integration/harness/static.ts'; 7 import type * as Fixture from './harness/retry-send.ts'; 8 declare global { 9 interface Window { 10 hcp087: typeof Fixture; 11 hcp087Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; 12 hcp087Pending: ReturnType< 13 Awaited<ReturnType<typeof Fixture.makeFixture>>['run'] 14 >; 15 hcp087Advance: () => void; 16 hcp087Release: () => void; 17 hcp087Waiting: boolean; 18 } 19 } 20 let server: Awaited<ReturnType<typeof createStaticHarness>>, 21 sockets: WebSocketServer, 22 endpoint: string, 23 bundle: string; 24 let events: { origin: string; wire: string }[] = [], 25 response: 'accepted' | 'refused' | 'unknown' | 'silent' = 'accepted'; 26 let archiveResponse: 'accepted' | 'refused' | 'unknown' | 'silent' | undefined; 27 let pendingAcks: { socket: import('ws').WebSocket; id: string }[] = []; 28 test.beforeAll(async () => { 29 server = await createStaticHarness(); 30 sockets = new WebSocketServer({ 31 host: '127.0.0.1', 32 port: 0, 33 maxPayload: 65536 34 }); 35 await once(sockets, 'listening'); 36 const address = sockets.address(); 37 if (!address || typeof address === 'string') 38 throw Error('loopback unavailable'); 39 endpoint = 'ws://127.0.0.1:' + address.port; 40 sockets.on('connection', (socket, request) => 41 socket.on('message', (bytes) => { 42 const raw = Buffer.isBuffer(bytes) 43 ? bytes 44 : Array.isArray(bytes) 45 ? Buffer.concat(bytes) 46 : Buffer.from(bytes), 47 frame = JSON.parse(raw.toString()) as unknown[]; 48 if (frame[0] !== 'EVENT') return; 49 const event = frame[1] as { id: string }; 50 pendingAcks.push({ socket, id: event.id }); 51 events.push({ 52 origin: new URL(request.url!, 'http://localhost').searchParams.get( 53 'origin' 54 )!, 55 wire: JSON.stringify(event) 56 }); 57 const outcome = 58 events.at(-1)!.origin === 'wss://archive.example.org' 59 ? (archiveResponse ?? response) 60 : response; 61 if (outcome !== 'silent') 62 socket.send( 63 JSON.stringify([ 64 'OK', 65 event.id, 66 outcome === 'accepted', 67 outcome === 'unknown' 68 ? 'Timeout' 69 : outcome === 'refused' 70 ? 'auth-required: fixture refusal' 71 : '' 72 ]) 73 ); 74 }) 75 ); 76 const result = await build({ 77 configFile: false, 78 logLevel: 'silent', 79 build: { 80 write: false, 81 minify: false, 82 lib: { 83 entry: fileURLToPath( 84 new URL('./harness/retry-send.ts', import.meta.url) 85 ), 86 name: 'hcp087', 87 formats: ['iife'] 88 } 89 } 90 }); 91 const output = Array.isArray(result) ? result[0] : result; 92 if (!('output' in output)) throw Error('bundle unavailable'); 93 const chunks = output.output.filter((x) => x.type === 'chunk'); 94 expect(chunks).toHaveLength(1); 95 bundle = chunks[0].code; 96 }); 97 test.afterAll(async () => { 98 for (const socket of sockets.clients) socket.terminate(); 99 await new Promise<void>((resolve) => sockets.close(() => resolve())); 100 await server.close(); 101 }); 102 async function load(page: import('@playwright/test').Page, initialise = true) { 103 await page.goto(server.url + '/search'); 104 await page.addScriptTag({ content: bundle }); 105 await page.evaluate(async (initialise) => { 106 window.hcp087Fixture = await window.hcp087.makeFixture(initialise); 107 }, initialise); 108 } 109 test.beforeEach(async ({ page }) => { 110 events = []; 111 response = 'accepted'; 112 archiveResponse = undefined; 113 pendingAcks = []; 114 await page.addInitScript( 115 ({ endpoint }) => { 116 const Native = window.WebSocket; 117 window.WebSocket = class extends Native { 118 constructor(url: string | URL, protocols?: string | string[]) { 119 const origin = new URL(String(url)).origin; 120 if ( 121 !['wss://peer.example.org', 'wss://archive.example.org'].includes( 122 origin 123 ) 124 ) 125 throw Error('unapproved destination'); 126 super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); 127 } 128 }; 129 }, 130 { endpoint } 131 ); 132 await load(page); 133 }); 134 test.afterEach(async ({ page }) => { 135 if (!page.isClosed()) 136 await page.evaluate(() => window.hcp087Fixture?.close()); 137 }); 138 test('successful same-owner observations preserve recovered rumor and both original artifacts', async ({ 139 page 140 }) => { 141 const r = await page.evaluate(async () => { 142 const f = window.hcp087Fixture, 143 prepared = await f.prepare(); 144 f.capture(); 145 const before = f.countsValue(), 146 result = await f.run(); 147 return { 148 prepared, 149 result, 150 before, 151 after: f.countsValue(), 152 recovered: f.recovered(), 153 row: await f.row() 154 }; 155 }); 156 expect(r.prepared.status).toBe('existing'); 157 expect(r.result.status).toBe('completed'); 158 expect(r.recovered.rumor).toBe(true); 159 expect(r.after.encrypts).toBe(r.before.encrypts); 160 expect(r.after.signs).toBe(r.before.signs); 161 expect(events.map((e) => e.wire)).toEqual([ 162 r.row.record.peerArtifact!.wire, 163 r.row.record.self.wire 164 ]); 165 }); 166 test('actual reload retries only the remaining original artifact with no re-sign or rewrap', async ({ 167 page 168 }) => { 169 archiveResponse = 'unknown'; 170 const original = await page.evaluate(async () => { 171 const f = window.hcp087Fixture; 172 await f.prepare(); 173 f.capture(); 174 const result = await f.run(); 175 if (result.status !== 'needs_action') 176 throw Error('missing real archive uncertainty'); 177 return (await f.row()).record; 178 }); 179 await page.evaluate(() => window.hcp087Fixture.close()); 180 await page.reload(); 181 await load(page, false); 182 response = 'accepted'; 183 archiveResponse = undefined; 184 events = []; 185 const r = await page.evaluate(async () => { 186 const f = window.hcp087Fixture, 187 baseline = f.countsValue(), 188 prepared = await f.prepare(); 189 f.capture(); 190 const before = f.countsValue(), 191 result = await f.run(); 192 return { 193 prepared, 194 result, 195 baseline, 196 before, 197 after: f.countsValue(), 198 row: (await f.row()).record 199 }; 200 }); 201 expect(r.result.status).toBe('completed'); 202 // The existing fixture's genuine capability probe already exercised crypto. 203 // Recovery and publication must add no encryption/signing to that baseline. 204 expect(r.before.encrypts).toBe(r.baseline.encrypts); 205 expect(r.before.signs).toBe(r.baseline.signs); 206 expect(r.before.decrypts - r.baseline.decrypts).toBe(2); 207 expect(r.after.encrypts).toBe(r.baseline.encrypts); 208 expect(r.after.signs).toBe(r.baseline.signs); 209 expect(r.row.self).toEqual(original.self); 210 expect(r.row.peerArtifact).toEqual(original.peerArtifact); 211 expect(events.map((e) => e.wire)).toEqual([original.self.wire]); 212 expect(r.row.receipts).toHaveLength(5); 213 }); 214 test('a second explicit action performs no duplicate accepted target work', async ({ 215 page 216 }) => { 217 const r = await page.evaluate(async () => { 218 const f = window.hcp087Fixture; 219 await f.prepare(); 220 f.capture(); 221 const first = await f.run(); 222 f.capture(); 223 const second = await f.run(); 224 return { first, second, row: (await f.row()).record }; 225 }); 226 expect(r.first.status).toBe('completed'); 227 expect(r.second.status).toBe('completed'); 228 expect(events).toHaveLength(2); 229 expect(r.row.receipts).toHaveLength(2); 230 }); 231 test('three real unknown attempts share one action and never schedule a fourth', async ({ 232 page 233 }) => { 234 response = 'unknown'; 235 const r = await page.evaluate(async () => { 236 const f = window.hcp087Fixture; 237 await f.prepare(); 238 f.capture(); 239 return { result: await f.run(), row: (await f.row()).record }; 240 }); 241 expect(r.result.status).toBe('needs_action'); 242 expect(events).toHaveLength(3); 243 expect(new Set(events.map((e) => e.wire)).size).toBe(1); 244 expect(r.row.receipts?.map((r) => r.attempt)).toEqual([1, 2, 3]); 245 expect(new Set(r.row.receipts?.map((r) => r.actionId)).size).toBe(1); 246 }); 247 test('authoritative auth refusal pauses without spinning or touching archive', async ({ 248 page 249 }) => { 250 response = 'refused'; 251 const r = await page.evaluate(async () => { 252 const f = window.hcp087Fixture; 253 await f.prepare(); 254 f.capture(); 255 return { result: await f.run(), row: (await f.row()).record }; 256 }); 257 expect(r.result.status).toBe('needs_action'); 258 expect(events).toHaveLength(1); 259 expect(r.row.receipts?.[0].status).toBe('refused'); 260 }); 261 test('wrong review and reused completed action cannot silently start another effect', async ({ 262 page 263 }) => { 264 const r = await page.evaluate(async () => { 265 const f = window.hcp087Fixture; 266 await f.prepare(); 267 const wrong = f.capture('unreviewed'); 268 f.capture(); 269 const refused = await f.run('unreviewed'); 270 const first = await f.run(); 271 const second = await f.run(); 272 return { wrong, refused, first, second }; 273 }); 274 expect(r.wrong).toBe(false); 275 expect(r.refused.status).toBe('invalid'); 276 expect(r.first.status).toBe('completed'); 277 expect(r.second.status).toBe('invalid'); 278 expect(events).toHaveLength(2); 279 }); 280 test('changed stored revision prevents all retry effects', async ({ page }) => { 281 const r = await page.evaluate(async () => { 282 const f = window.hcp087Fixture; 283 await f.prepare(); 284 f.capture(); 285 await f.write('revision'); 286 return f.run(); 287 }); 288 expect(r.status).toBe('needs_action'); 289 expect(events).toEqual([]); 290 }); 291 test('Stop before execution fences every effect and preserves ciphertext', async ({ 292 page 293 }) => { 294 const r = await page.evaluate(async () => { 295 const f = window.hcp087Fixture; 296 await f.prepare(); 297 f.capture(); 298 const before = await f.row(); 299 f.stop(); 300 return { result: await f.run(), before, after: await f.row() }; 301 }); 302 expect(r.result.status).toBe('stopped'); 303 expect(r.after.wire).toBe(r.before.wire); 304 expect(events).toEqual([]); 305 }); 306 test('actual changed owner retires recovered private body before any EVENT', async ({ 307 page 308 }) => { 309 const r = await page.evaluate(async () => { 310 const f = window.hcp087Fixture; 311 await f.prepare(); 312 f.capture(); 313 f.mode('changed_key'); 314 return { result: await f.run(), recovered: f.recovered() }; 315 }); 316 expect(r.result.status).toBe('stopped'); 317 expect(r.recovered.rumor).toBe(false); 318 expect(events).toEqual([]); 319 }); 320 test('missing persisted ciphertext cannot become a successful retry', async ({ 321 page 322 }) => { 323 const r = await page.evaluate(async () => { 324 const f = window.hcp087Fixture; 325 await f.prepare(); 326 f.capture(); 327 await f.write('erase'); 328 return f.run(); 329 }); 330 expect(r.status).toBe('needs_action'); 331 expect(events).toEqual([]); 332 }); 333 test('the shared 45 second network budget ends a real silent attempt without another EVENT', async ({ 334 page 335 }) => { 336 response = 'silent'; 337 await page.evaluate(async () => { 338 const f = window.hcp087Fixture; 339 await f.prepare(); 340 f.capture(); 341 const native = performance.now.bind(performance); 342 let offset = 0; 343 Object.defineProperty(performance, 'now', { 344 configurable: true, 345 value: () => native() + offset 346 }); 347 window.hcp087Advance = () => { 348 offset += 45001; 349 }; 350 window.hcp087Pending = f.run(); 351 }); 352 await expect.poll(() => events.length).toBe(1); 353 await page.evaluate(() => window.hcp087Advance()); 354 const r = await page.evaluate(() => window.hcp087Pending); 355 expect(r.status).toBe('needs_action'); 356 expect(events).toHaveLength(1); 357 }); 358 test('time spent awaiting the genuine provider observation is outside network budget', async ({ 359 page 360 }) => { 361 await page.evaluate(async () => { 362 const f = window.hcp087Fixture; 363 await f.prepare(); 364 f.capture(); 365 const native = performance.now.bind(performance); 366 let offset = 0; 367 Object.defineProperty(performance, 'now', { 368 configurable: true, 369 value: () => native() + offset 370 }); 371 const provider = window.nostr as { getPublicKey(): Promise<string> }; 372 const original = provider.getPublicKey.bind(provider); 373 let held = true; 374 provider.getPublicKey = async () => { 375 if (held) { 376 held = false; 377 window.hcp087Waiting = true; 378 await new Promise<void>((resolve) => { 379 window.hcp087Release = resolve; 380 }); 381 } 382 return original(); 383 }; 384 window.hcp087Advance = () => { 385 offset += 60000; 386 }; 387 window.hcp087Pending = f.run(); 388 }); 389 await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true); 390 expect(events).toEqual([]); 391 await page.evaluate(() => { 392 window.hcp087Advance(); 393 window.hcp087Release(); 394 }); 395 const r = await page.evaluate(() => window.hcp087Pending); 396 expect(r.status).toBe('completed'); 397 expect(events).toHaveLength(2); 398 }); 399 test('a controlled genuine receipt successor accepted during key wait suppresses duplicate target publication', async ({ 400 page 401 }) => { 402 await page.evaluate(async () => { 403 const f = window.hcp087Fixture; 404 await f.prepare(); 405 f.capture(); 406 const provider = window.nostr as { getPublicKey(): Promise<string> }, 407 original = provider.getPublicKey.bind(provider); 408 let calls = 0; 409 provider.getPublicKey = async () => { 410 calls++; 411 if (calls === 2) { 412 window.hcp087Waiting = true; 413 await new Promise<void>((resolve) => { 414 window.hcp087Release = resolve; 415 }); 416 } 417 return original(); 418 }; 419 window.hcp087Pending = f.run(); 420 }); 421 await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true); 422 expect(events).toHaveLength(1); 423 const successor = await page.evaluate(() => 424 window.hcp087Fixture.controlledArchiveSuccessor() 425 ); 426 expect(successor.status).toBe('saved'); 427 await page.evaluate(() => window.hcp087Release()); 428 const result = await page.evaluate(() => window.hcp087Pending); 429 expect(result.status).toBe('completed'); 430 expect(events).toHaveLength(1); 431 }); 432 test('network time consumed by earlier real attempts reduces the remaining action allowance', async ({ 433 page 434 }) => { 435 response = 'silent'; 436 await page.evaluate(async () => { 437 const f = window.hcp087Fixture; 438 await f.prepare(); 439 f.capture(); 440 const native = performance.now.bind(performance); 441 let offset = 0; 442 Object.defineProperty(performance, 'now', { 443 configurable: true, 444 value: () => native() + offset 445 }); 446 window.hcp087Advance = () => { 447 offset += 30000; 448 }; 449 window.hcp087Pending = f.run(); 450 }); 451 await expect.poll(() => events.length).toBe(1); 452 await page.evaluate(() => window.hcp087Advance()); 453 pendingAcks[0].socket.send( 454 JSON.stringify(['OK', pendingAcks[0].id, false, 'Timeout']) 455 ); 456 await expect.poll(() => events.length).toBe(2); 457 await page.evaluate(() => window.hcp087Advance()); 458 pendingAcks[1].socket.send( 459 JSON.stringify(['OK', pendingAcks[1].id, false, 'Timeout']) 460 ); 461 const r = await page.evaluate(async () => ({ 462 result: await window.hcp087Pending, 463 row: (await window.hcp087Fixture.row()).record 464 })); 465 expect(r.result.status).toBe('needs_action'); 466 expect(events).toHaveLength(2); 467 expect(events[1].wire).toBe(events[0].wire); 468 expect(r.row.receipts?.map((f) => f.status)).toEqual([ 469 'unknown', 470 'timed_out' 471 ]); 472 }); 473 test('a codec-valid success row inserted between verification and load cannot claim genuine completion', async ({ 474 page 475 }) => { 476 const r = await page.evaluate(async () => { 477 const f = window.hcp087Fixture; 478 await f.prepare(); 479 f.capture(); 480 const mutation = await f.injectUnacknowledgedSuccessBetweenReads(), 481 proofBefore = f.proof(), 482 result = await f.run(), 483 injected = f.injected(); 484 f.clearFault(); 485 return { 486 mutation, 487 proofBefore, 488 proofAfter: f.proof(), 489 result, 490 injected, 491 row: await f.row() 492 }; 493 }); 494 expect(r.injected).toBe(1); 495 expect(r.row.wire).toBe(r.mutation.changedWire); 496 expect(r.proofAfter).toEqual(r.proofBefore); 497 expect(r.proofAfter?.revision).toBe(r.mutation.revision); 498 expect(r.result.status).toBe('needs_action'); 499 expect(events).toEqual([]); 500 });