stop-send.spec.ts (17237B)
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/stop-send.ts'; 8 declare global { 9 interface Window { 10 hcp089: typeof Fixture; 11 hcp089Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; 12 hcp089Pending: ReturnType< 13 Awaited<ReturnType<typeof Fixture.makeFixture>>['run'] 14 >; 15 hcp089Advance: () => void; 16 hcp089Release: () => void; 17 hcp089Waiting: 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/stop-send.ts', import.meta.url) 85 ), 86 name: 'hcp089', 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.hcp089Fixture = await window.hcp089.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.hcp089Fixture?.close()); 137 }); 138 test('Stop after an actual silent EVENT preserves original uncertain target receipt', async ({ 139 page 140 }) => { 141 response = 'silent'; 142 const before = await page.evaluate(async () => { 143 const f = window.hcp089Fixture; 144 await f.prepare(); 145 f.capture(); 146 const before = await f.row(); 147 window.hcp089Pending = f.run(); 148 return before; 149 }); 150 await expect.poll(() => events.length).toBe(1); 151 const r = await page.evaluate(async () => { 152 const f = window.hcp089Fixture; 153 f.stop(); 154 return { 155 result: await window.hcp089Pending, 156 row: await f.row(), 157 snapshot: f.snapshot() 158 }; 159 }); 160 expect(r.result.status).toBe('stopped'); 161 expect(events).toHaveLength(1); 162 expect(r.row.record.self).toEqual(before.record.self); 163 expect(r.row.record.peerArtifact).toEqual(before.record.peerArtifact); 164 expect(r.row.record.receipts).toHaveLength(1); 165 expect(r.row.record.receipts![0]).toMatchObject({ 166 role: 'peer', 167 origin: 'wss://peer.example.org', 168 eventId: before.record.peerArtifact!.eventId, 169 status: 'stopped', 170 attempt: 1 171 }); 172 }); 173 test('disconnect during actual publish retains original-owner uncertainty without archive or auto resume', async ({ 174 page 175 }) => { 176 response = 'silent'; 177 const before = await page.evaluate(async () => { 178 const f = window.hcp089Fixture; 179 await f.prepare(); 180 f.capture(); 181 const before = await f.row(); 182 window.hcp089Pending = f.run(); 183 return before; 184 }); 185 await expect.poll(() => events.length).toBe(1); 186 const r = await page.evaluate(async () => { 187 const f = window.hcp089Fixture; 188 f.disconnect(); 189 const result = await window.hcp089Pending; 190 return { 191 result, 192 row: await f.row(), 193 recapture: f.capture(), 194 rerun: await f.run() 195 }; 196 }); 197 expect(r.result.status).toBe('stopped'); 198 expect(r.recapture).toBe(false); 199 expect(r.rerun.status).toBe('invalid'); 200 expect(events).toHaveLength(1); 201 expect(r.row.record.owner).toBe(before.record.owner); 202 expect(r.row.record.self).toEqual(before.record.self); 203 expect(r.row.record.peerArtifact).toEqual(before.record.peerArtifact); 204 expect(r.row.record.receipts).toHaveLength(1); 205 expect(r.row.record.receipts![0].status).toBe('stopped'); 206 }); 207 test('Stop before execution preserves exact bytes with no attempted fact or EVENT', async ({ 208 page 209 }) => { 210 const r = await page.evaluate(async () => { 211 const f = window.hcp089Fixture; 212 await f.prepare(); 213 f.capture(); 214 const before = await f.row(); 215 f.stop(); 216 return { before, after: await f.row(), result: await f.run() }; 217 }); 218 expect(r.result.status).toBe('stopped'); 219 expect(r.after.wire).toBe(r.before.wire); 220 expect(events).toEqual([]); 221 }); 222 test('late ACK after Stop cannot erase uncertainty or publish sender archive', async ({ 223 page 224 }) => { 225 response = 'silent'; 226 await page.evaluate(async () => { 227 const f = window.hcp089Fixture; 228 await f.prepare(); 229 f.capture(); 230 window.hcp089Pending = f.run(); 231 }); 232 await expect.poll(() => events.length).toBe(1); 233 const r = await page.evaluate(async () => { 234 const f = window.hcp089Fixture; 235 f.stop(); 236 await window.hcp089Pending; 237 return f.row(); 238 }); 239 for (const ack of pendingAcks) 240 if (ack.socket.readyState === 1) 241 ack.socket.send(JSON.stringify(['OK', ack.id, true, ''])); 242 const after = await page.evaluate(() => window.hcp089Fixture.row()); 243 expect(r.record.receipts).toHaveLength(1); 244 expect(r.record.receipts![0].status).toBe('stopped'); 245 expect(after.wire).toBe(r.wire); 246 expect(events).toHaveLength(1); 247 }); 248 test('real accepted SDK result crossing Stop and logout during receipt read preserves acceptance', async ({ 249 page 250 }) => { 251 await page.evaluate(async () => { 252 const f = window.hcp089Fixture; 253 await f.prepare(); 254 f.capture(); 255 let acknowledged = false, 256 stopped = false; 257 // Observe the actual SDK socket's OK before the receipt read. The native 258 // transport still receives and verifies the same frame through Applesauce. 259 const cursor = Reflect.get<IDBIndex, 'openCursor'>( 260 IDBIndex.prototype, 261 'openCursor' 262 ); 263 const Native = window.WebSocket; 264 window.WebSocket = class extends Native { 265 constructor(url: string | URL, protocols?: string | string[]) { 266 super(url, protocols); 267 this.addEventListener('message', (event) => { 268 const frame = JSON.parse(String(event.data)) as unknown[]; 269 if (frame[0] === 'OK' && frame[2] === true) acknowledged = true; 270 }); 271 } 272 }; 273 IDBIndex.prototype.openCursor = function ( 274 ...args: Parameters<IDBIndex['openCursor']> 275 ) { 276 if ( 277 acknowledged && 278 !stopped && 279 this.objectStore.name === 'private_sends' 280 ) { 281 stopped = true; 282 f.stop(); 283 f.disconnect(); 284 } 285 return cursor.apply(this, args); 286 }; 287 try { 288 window.hcp089Pending = f.run(); 289 await window.hcp089Pending; 290 } finally { 291 IDBIndex.prototype.openCursor = cursor; 292 window.WebSocket = Native; 293 } 294 window.hcp089Waiting = stopped; 295 }); 296 const r = await page.evaluate(async () => ({ 297 stopped: window.hcp089Waiting, 298 result: await window.hcp089Pending, 299 row: await window.hcp089Fixture.row(), 300 status: await window.hcp089Fixture.sendStatus() 301 })); 302 expect(r.stopped).toBe(true); 303 expect(r.result.status).toBe('stopped'); 304 expect(events).toHaveLength(1); 305 expect(r.row.record.receipts).toHaveLength(1); 306 expect(r.row.record.receipts![0].status).toBe('accepted'); 307 expect(r.status!.recipient.acceptedTargets).toEqual([ 308 'wss://peer.example.org' 309 ]); 310 expect(r.status!.archive.state).toBe('pending'); 311 }); 312 test('actual original-owner settlement survives logout, is idempotent and rejects a cloned result', async ({ 313 page 314 }) => { 315 const r = await page.evaluate(async () => { 316 const f = window.hcp089Fixture; 317 await f.prepare(); 318 const before = await f.row(); 319 const result = await f.publishObserved(); 320 f.disconnect(); 321 const counts = f.countsValue(); 322 const clone = await f.settleObserved(true), 323 first = await f.settleObserved(), 324 after = await f.row(), 325 again = await f.settleObserved(), 326 final = await f.row(); 327 return { 328 result, 329 before, 330 clone, 331 first: first.status, 332 again: again.status, 333 after, 334 final, 335 counts, 336 countsAfter: f.countsValue() 337 }; 338 }); 339 expect(r.result.status).toBe('accepted'); 340 expect(r.clone.status).toBe('invalid'); 341 expect(r.first).toBe('saved'); 342 expect(r.again).toBe('existing'); 343 expect(r.after.wire).toBe(r.final.wire); 344 expect(r.after.record.receipts).toHaveLength(1); 345 expect(r.after.record.owner).toBe(r.before.record.owner); 346 expect(r.after.record.self).toEqual(r.before.record.self); 347 expect(r.after.record.peerArtifact).toEqual(r.before.record.peerArtifact); 348 expect(r.countsAfter).toEqual(r.counts); 349 expect(events).toHaveLength(1); 350 }); 351 test('late actual result cannot attach to a different immutable operation scope', async ({ 352 page 353 }) => { 354 const r = await page.evaluate(async () => { 355 const f = window.hcp089Fixture; 356 await f.prepare(); 357 await f.publishObserved(); 358 const wire = await f.replaceImmutableScope(); 359 return { wire, result: await f.settleObserved(), after: await f.row() }; 360 }); 361 expect(r.result.status).toBe('conflict'); 362 expect(r.after.wire).toBe(r.wire); 363 expect(r.after.record.receipts).toBeUndefined(); 364 expect(events).toHaveLength(1); 365 }); 366 test('real settlement IDB abort is not durable success and explicit metadata retry preserves the original result', async ({ 367 page 368 }) => { 369 const r = await page.evaluate(async () => { 370 const f = window.hcp089Fixture; 371 await f.prepare(); 372 await f.publishObserved(); 373 const before = await f.row(); 374 f.disconnect(); 375 f.faultSettlement('abort'); 376 const failed = await f.settleObserved(); 377 f.clearFault(); 378 const after = await f.row(); 379 const retried = await f.settleObserved(); 380 return { 381 before, 382 after, 383 failed, 384 retried: retried.status, 385 row: await f.row() 386 }; 387 }); 388 expect(r.failed.status).toBe('aborted'); 389 expect(r.after.wire).toBe(r.before.wire); 390 expect(r.retried).toBe('saved'); 391 expect(r.row.record.receipts).toHaveLength(1); 392 expect(events).toHaveLength(1); 393 }); 394 test('real post-put settlement readback failure remains unknown despite committed bytes', async ({ 395 page 396 }) => { 397 const r = await page.evaluate(async () => { 398 const f = window.hcp089Fixture; 399 await f.prepare(); 400 await f.publishObserved(); 401 f.disconnect(); 402 f.faultSettlement('readback'); 403 const failed = await f.settleObserved(); 404 f.clearFault(); 405 const retried = await f.settleObserved(); 406 return { failed, retried: retried.status, row: await f.row() }; 407 }); 408 expect(r.failed.status).toBe('unknown_completion'); 409 expect(r.retried).toBe('existing'); 410 expect(r.row.record.receipts).toHaveLength(1); 411 expect(events).toHaveLength(1); 412 }); 413 test('stopped projection retains uncertain target and honest recipient/archive language', async ({ 414 page 415 }) => { 416 response = 'silent'; 417 await page.evaluate(async () => { 418 const f = window.hcp089Fixture; 419 await f.prepare(); 420 f.capture(); 421 window.hcp089Pending = f.run(); 422 }); 423 await expect.poll(() => events.length).toBe(1); 424 const r = await page.evaluate(async () => { 425 const f = window.hcp089Fixture; 426 f.stop(); 427 await window.hcp089Pending; 428 return { snapshot: f.snapshot(), status: await f.sendStatus() }; 429 }); 430 expect(r.snapshot!.labels).toContain('Stopped'); 431 expect(r.status!.recipient.uncertainTargets).toEqual([ 432 'wss://peer.example.org' 433 ]); 434 expect(r.status!.labels).toContain('Recipient delivery unknown'); 435 expect(r.status!.labels).toContain('Sender archive pending'); 436 expect([...r.snapshot!.labels, ...r.status!.labels].join(' ')).not.toMatch( 437 /Order accepted|Seen|Read|Delivered to person|permanent retention|guaranteed notification/ 438 ); 439 }); 440 test('reload remembers ciphertext but only explicit matching-owner Resume publishes original artifacts', async ({ 441 page 442 }) => { 443 response = 'silent'; 444 const before = await page.evaluate(async () => { 445 const f = window.hcp089Fixture; 446 await f.prepare(); 447 f.capture(); 448 const row = await f.row(); 449 window.hcp089Pending = f.run(); 450 return row; 451 }); 452 await expect.poll(() => events.length).toBe(1); 453 const stopped = await page.evaluate(async () => { 454 const f = window.hcp089Fixture; 455 f.stop(); 456 await window.hcp089Pending; 457 return f.row(); 458 }); 459 await page.reload(); 460 await load(page, false); 461 expect(events).toHaveLength(1); 462 const captured = await page.evaluate(async () => { 463 const f = window.hcp089Fixture; 464 const prepared = await f.prepare(); 465 return { prepared, captured: f.capture(), row: await f.row() }; 466 }); 467 expect(captured.prepared.status).toBe('existing'); 468 expect(captured.captured).toBe(true); 469 expect(events).toHaveLength(1); 470 expect(captured.row.wire).toBe(stopped.wire); 471 response = 'accepted'; 472 const resumed = await page.evaluate(async () => ({ 473 result: await window.hcp089Fixture.run(), 474 row: await window.hcp089Fixture.row() 475 })); 476 expect(resumed.result.status).toBe('completed'); 477 expect(events).toHaveLength(3); 478 expect(events.slice(1).map((e) => e.wire)).toEqual([ 479 before.record.peerArtifact!.wire, 480 before.record.self.wire 481 ]); 482 expect(resumed.row.record.receipts).toHaveLength(3); 483 expect(resumed.row.record.receipts![0]).toEqual(stopped.record.receipts![0]); 484 }); 485 test('Stop in sender archive preserves actual prior recipient acceptance and partial archive uncertainty', async ({ 486 page 487 }) => { 488 archiveResponse = 'silent'; 489 await page.evaluate(async () => { 490 const f = window.hcp089Fixture; 491 await f.prepare(); 492 f.capture(); 493 window.hcp089Pending = f.run(); 494 }); 495 await expect.poll(() => events.length).toBe(2); 496 const r = await page.evaluate(async () => { 497 const f = window.hcp089Fixture; 498 f.stop(); 499 const result = await window.hcp089Pending; 500 return { result, row: await f.row(), status: await f.sendStatus() }; 501 }); 502 expect(r.result.status).toBe('stopped'); 503 expect(events).toHaveLength(2); 504 expect(r.row.record.receipts!.map((f) => [f.role, f.status])).toEqual([ 505 ['peer', 'accepted'], 506 ['self_archive', 'stopped'] 507 ]); 508 expect(r.status!.recipient.state).toBe('accepted_by_inbox_relay'); 509 expect(r.status!.archive.state).toBe('pending'); 510 expect(r.status!.partial).toBe(true); 511 expect(r.status!.labels).toContain('Accepted by recipient inbox relay'); 512 expect(r.status!.labels).toContain('Partial delivery'); 513 expect(r.status!.labels).toContain('Sender archive pending'); 514 });