private-preparation.spec.ts (19186B)
1 import { expect, test, type Page } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { createStaticHarness } from '../integration/harness/static.ts'; 5 import type * as Preparation from './harness/private-preparation.ts'; 6 declare global { 7 interface Window { 8 hcp084: typeof Preparation; 9 hcp084Fixture: Awaited<ReturnType<typeof Preparation.makeFixture>>; 10 } 11 } 12 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; 13 test.beforeAll(async () => { 14 server = await createStaticHarness(); 15 const built = await build({ 16 configFile: false, 17 logLevel: 'silent', 18 build: { 19 write: false, 20 minify: false, 21 lib: { 22 entry: fileURLToPath( 23 new URL('./harness/private-preparation.ts', import.meta.url) 24 ), 25 name: 'hcp084', 26 formats: ['iife'] 27 } 28 } 29 }); 30 const output = Array.isArray(built) ? built[0] : built; 31 if (!('output' in output)) throw Error('private fixture bundle missing'); 32 const chunks = output.output.filter((entry) => entry.type === 'chunk'); 33 expect(chunks).toHaveLength(1); 34 bundle = chunks[0].code; 35 }); 36 test.afterAll(async () => server.close()); 37 test.afterEach(async ({ page }) => { 38 await page.evaluate(() => window.hcp084Fixture?.close()); 39 }); 40 test('genuine enquiry binding admits only exact canonical captured body and preserves prior acknowledgement on mismatch', async ({ 41 page 42 }) => { 43 await load(page); 44 const result = await page.evaluate(async () => { 45 const f = window.hcp084Fixture, 46 s = window.hcp084, 47 context = await f.enquiryContext(), 48 different = await f.enquiryContext('Different carrots'); 49 s.updatePrivateComposerText(f.composer, f.marker, 'reviewed_private_text'); 50 const bound = s.bindPrivateComposerPreparation( 51 f.composer, 52 f.reserved, 53 f.preparation, 54 context, 55 'reviewed_composer_preparation' 56 ); 57 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 58 const saved = s.privateComposerSnapshot(f.composer), 59 bytes = await f.stored(), 60 wrongContext = s.bindPrivateComposerPreparation( 61 f.composer, 62 f.reserved, 63 f.preparation, 64 different, 65 'reviewed_composer_preparation' 66 ), 67 afterContext = s.privateComposerSnapshot(f.composer); 68 s.updatePrivateComposerText( 69 f.composer, 70 'different private body', 71 'reviewed_private_text' 72 ); 73 const wrongBody = s.bindPrivateComposerPreparation( 74 f.composer, 75 f.reserved, 76 f.preparation, 77 context, 78 'reviewed_composer_preparation' 79 ); 80 return { 81 bound, 82 saved: saved?.state, 83 wrongContext, 84 unchangedAck: afterContext?.state === saved?.state, 85 wrongBody, 86 dirty: s.privateComposerSnapshot(f.composer)?.dirty, 87 text: s.privateComposerText(f.composer), 88 bytes: bytes === (await f.stored()) 89 }; 90 }); 91 expect(result).toEqual({ 92 bound: true, 93 saved: 'saved_encrypted', 94 wrongContext: false, 95 unchangedAck: true, 96 wrongBody: false, 97 dirty: true, 98 text: 'different private body', 99 bytes: true 100 }); 101 }); 102 async function load(page: Page) { 103 await page.goto(server.url + '/search'); 104 await page.addScriptTag({ content: bundle }); 105 await page.evaluate(async () => { 106 window.hcp084Fixture = await window.hcp084.makeFixture(); 107 }); 108 } 109 test('same-page confirmation defaults Keep editing and Escape preserves exact text and privacy', async ({ 110 page 111 }) => { 112 const logs: string[] = []; 113 page.on('console', (entry) => logs.push(entry.text())); 114 await load(page); 115 const original = await page.evaluate(() => { 116 const f = window.hcp084Fixture; 117 return { 118 text: f.original, 119 result: f.requestClose(), 120 snapshot: window.hcp084.privateComposerSnapshot(f.composer) 121 }; 122 }); 123 expect(original.result).toBe('confirmation_required'); 124 expect(original.snapshot?.dirty).toBe(true); 125 await expect( 126 page.getByRole('button', { name: 'Keep editing', exact: true }) 127 ).toBeFocused(); 128 await page.getByRole('button', { name: 'Keep editing', exact: true }).click(); 129 await expect( 130 page.getByRole('textbox', { name: 'Private text', exact: true }) 131 ).toHaveValue(original.text); 132 await page.evaluate(() => window.hcp084Fixture.requestClose()); 133 await page.keyboard.press('Escape'); 134 await expect( 135 page.getByRole('textbox', { name: 'Private text', exact: true }) 136 ).toHaveValue(original.text); 137 const privacy = await page.evaluate(async () => { 138 const f = window.hcp084Fixture; 139 return { 140 public: (await f.publicDraftRows()).includes(f.marker), 141 private: (await f.stored()).includes(f.marker), 142 storage: JSON.stringify(localStorage).includes(f.marker), 143 url: location.href.includes(f.marker), 144 snapshot: JSON.stringify( 145 window.hcp084.privateComposerSnapshot(f.composer) 146 ).includes(f.marker) 147 }; 148 }); 149 expect(privacy).toEqual({ 150 public: false, 151 private: false, 152 storage: false, 153 url: false, 154 snapshot: false 155 }); 156 expect( 157 logs.some((line) => 158 line.includes('HCP081_PRIVATE_TEXT_MEMORY_ONLY_SENTINEL') 159 ) 160 ).toBe(false); 161 }); 162 test('stale discard cannot clear new edits; reviewed same-revision discard is one-shot', async ({ 163 page 164 }) => { 165 await load(page); 166 const result = await page.evaluate(() => { 167 const f = window.hcp084Fixture, 168 s = window.hcp084; 169 f.requestClose(); 170 s.updatePrivateComposerText( 171 f.composer, 172 'newer private value', 173 'reviewed_private_text' 174 ); 175 const stale = s.confirmDiscardNavigation( 176 f.navigation, 177 'reviewed_discard_private_text' 178 ), 179 kept = s.privateComposerText(f.composer); 180 f.requestClose(); 181 const denied = s.confirmDiscardNavigation(f.navigation, 'unreviewed'), 182 accepted = s.confirmDiscardNavigation( 183 f.navigation, 184 'reviewed_discard_private_text' 185 ); 186 return { 187 stale, 188 kept, 189 denied, 190 accepted, 191 text: s.privateComposerText(f.composer), 192 repeated: s.confirmDiscardNavigation( 193 f.navigation, 194 'reviewed_discard_private_text' 195 ) 196 }; 197 }); 198 expect(result).toEqual({ 199 stale: 'review_required', 200 kept: 'newer private value', 201 denied: 'invalid', 202 accepted: 'allowed', 203 text: '', 204 repeated: 'invalid' 205 }); 206 }); 207 test('beforeunload warns only while exact private text lacks encrypted acknowledgement', async ({ 208 page 209 }) => { 210 await load(page); 211 const result = await page.evaluate(async () => { 212 const f = window.hcp084Fixture, 213 s = window.hcp084, 214 detach = s.attachPrivateBeforeUnload(f.navigation); 215 const first = new Event('beforeunload', { cancelable: true }); 216 window.dispatchEvent(first); 217 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 218 const saved = s.privateComposerSnapshot(f.composer), 219 second = new Event('beforeunload', { cancelable: true }); 220 window.dispatchEvent(second); 221 detach?.(); 222 return { 223 dirtyPrevented: first.defaultPrevented, 224 savedPrevented: second.defaultPrevented, 225 saved: saved?.state, 226 dirty: saved?.dirty 227 }; 228 }); 229 expect(result).toEqual({ 230 dirtyPrevented: true, 231 savedPrevented: false, 232 saved: 'saved_encrypted', 233 dirty: false 234 }); 235 }); 236 test('acknowledged ciphertext labels only captured text revision; newer value stays unsaved', async ({ 237 page 238 }) => { 239 await load(page); 240 const result = await page.evaluate(async () => { 241 const f = window.hcp084Fixture, 242 s = window.hcp084; 243 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 244 const saved = s.privateComposerSnapshot(f.composer), 245 bytes = await f.stored(); 246 s.updatePrivateComposerText( 247 f.composer, 248 'edited after capture', 249 'reviewed_private_text' 250 ); 251 const changed = s.privateComposerSnapshot(f.composer); 252 return { 253 saved: saved?.state, 254 changed: changed?.state, 255 dirty: changed?.dirty, 256 value: s.privateComposerText(f.composer), 257 unchanged: bytes === (await f.stored()), 258 plaintext: (await f.stored()).includes('edited after capture') 259 }; 260 }); 261 expect(result).toEqual({ 262 saved: 'saved_encrypted', 263 changed: 'unsaved', 264 dirty: true, 265 value: 'edited after capture', 266 unchanged: true, 267 plaintext: false 268 }); 269 }); 270 for (const mode of ['declined', 'missing', 'changed_key'] as const) 271 test( 272 mode + ' self preparation never labels dirty text saved', 273 async ({ page }) => { 274 await load(page); 275 const result = await page.evaluate(async (mode) => { 276 const f = window.hcp084Fixture, 277 s = window.hcp084; 278 f.mode(mode); 279 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 280 const state = s.privateComposerSnapshot(f.composer); 281 return { 282 saved: state?.state === 'saved_encrypted', 283 dirty: state?.dirty ?? true, 284 receipt: !!s.preparedSelfRecovery(f.preparation), 285 plaintext: (await f.stored()).includes(f.marker) 286 }; 287 }, mode); 288 expect(result).toEqual({ 289 saved: false, 290 dirty: true, 291 receipt: false, 292 plaintext: false 293 }); 294 } 295 ); 296 for (const mode of ['abort', 'unknown'] as const) 297 test( 298 mode + ' actual self transaction cannot turn draft into a fresh send', 299 async ({ page }) => { 300 await load(page); 301 const result = await page.evaluate(async (mode) => { 302 const f = window.hcp084Fixture, 303 s = window.hcp084, 304 hits = f.fault(mode); 305 const outcome = await s.prepareSelfRecovery( 306 f.preparation, 307 'reviewed_self_recovery' 308 ), 309 state = s.privateComposerSnapshot(f.composer); 310 return { 311 outcome: outcome.status, 312 hits: hits(), 313 state: state?.state, 314 dirty: state?.dirty, 315 plaintext: (await f.stored()).includes(f.marker), 316 value: s.privateComposerText(f.composer) === f.original 317 }; 318 }, mode); 319 expect(result).toEqual( 320 mode === 'abort' 321 ? { 322 outcome: 'aborted', 323 hits: 1, 324 state: 'needs_action', 325 dirty: true, 326 plaintext: false, 327 value: true 328 } 329 : { 330 outcome: 'reconciled', 331 hits: 1, 332 state: 'saved_encrypted', 333 dirty: false, 334 plaintext: false, 335 value: true 336 } 337 ); 338 } 339 ); 340 for (const action of ['discard', 'disconnect'] as const) 341 test( 342 action + 343 ' during real SDK wait preserves pending owner occupancy and cannot advance effects', 344 async ({ page }) => { 345 await load(page); 346 await page.evaluate(() => { 347 const f = window.hcp084Fixture; 348 f.mode('hold_encrypt'); 349 Reflect.set( 350 window, 351 'hcp084Pending', 352 window.hcp084.prepareSelfRecovery( 353 f.preparation, 354 'reviewed_self_recovery' 355 ) 356 ); 357 }); 358 await expect 359 .poll(() => 360 page.evaluate(() => window.hcp084Fixture.pendingEncryption()) 361 ) 362 .toBe(true); 363 const waiting = await page.evaluate((action) => { 364 const f = window.hcp084Fixture, 365 s = window.hcp084; 366 if (action === 'discard') { 367 f.requestClose(); 368 s.confirmDiscardNavigation( 369 f.navigation, 370 'reviewed_discard_private_text' 371 ); 372 } else s.disconnectIdentity(f.identity); 373 return { 374 pending: f.pendingEncryption(), 375 receipt: !!s.preparedSelfRecovery(f.preparation), 376 text: s.privateComposerText(f.composer) ?? '', 377 bytes: f.counts().encrypts 378 }; 379 }, action); 380 expect(waiting.pending).toBe(true); 381 expect(waiting.receipt).toBe(false); 382 expect(waiting.text).toBe(''); 383 const settled = await page.evaluate(async () => { 384 const f = window.hcp084Fixture; 385 f.settle(); 386 const result = (await Reflect.get(window, 'hcp084Pending')) as { 387 status: string; 388 }; 389 return { 390 status: result.status, 391 pending: f.pendingEncryption(), 392 receipt: !!window.hcp084.preparedSelfRecovery(f.preparation), 393 plaintext: (await f.stored()).includes(f.marker) 394 }; 395 }); 396 expect(settled).toEqual({ 397 status: 'stopped', 398 pending: false, 399 receipt: false, 400 plaintext: false 401 }); 402 } 403 ); 404 for (const mode of ['abort', 'unknown'] as const) 405 test( 406 mode + 407 ' pair transaction retains only genuine local self fact and no remote effect', 408 async ({ page }) => { 409 let sockets = 0; 410 page.on('websocket', () => sockets++); 411 await load(page); 412 const result = await page.evaluate(async (mode) => { 413 const f = window.hcp084Fixture, 414 s = window.hcp084; 415 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 416 const old = await f.stored(), 417 hits = f.fault(mode), 418 result = await s.preparePairedDelivery( 419 f.preparation, 420 f.context, 421 'reviewed_pair_preparation' 422 ), 423 snapshot = s.privateComposerSnapshot(f.composer); 424 return { 425 status: result.status, 426 hits: hits(), 427 state: snapshot?.state, 428 pair: snapshot?.pairState, 429 dirty: snapshot?.dirty, 430 unchanged: old === (await f.stored()), 431 plaintext: (await f.stored()).includes(f.marker) 432 }; 433 }, mode); 434 expect(result).toEqual( 435 mode === 'abort' 436 ? { 437 status: 'aborted', 438 hits: 1, 439 state: 'saved_encrypted', 440 pair: 'needs_action', 441 dirty: false, 442 unchanged: true, 443 plaintext: false 444 } 445 : { 446 status: 'reconciled', 447 hits: 1, 448 state: 'saved_encrypted', 449 pair: 'prepared', 450 dirty: false, 451 unchanged: false, 452 plaintext: false 453 } 454 ); 455 expect(sockets).toBe(0); 456 } 457 ); 458 test('body budget and unreviewed edits preserve prior exact memory value', async ({ 459 page 460 }) => { 461 await load(page); 462 const result = await page.evaluate(() => { 463 const f = window.hcp084Fixture, 464 s = window.hcp084; 465 return { 466 oversized: s.updatePrivateComposerText( 467 f.composer, 468 'x'.repeat(4097), 469 'reviewed_private_text' 470 ), 471 unreviewed: s.updatePrivateComposerText( 472 f.composer, 473 'replacement', 474 'unreviewed' 475 ), 476 equal: s.privateComposerText(f.composer) === f.original 477 }; 478 }); 479 expect(result).toEqual({ oversized: false, unreviewed: false, equal: true }); 480 }); 481 482 for (const role of ['self', 'pair'] as const) 483 test( 484 role + 485 ' actual committed write with unavailable readback remains uncertain instead of fresh', 486 async ({ page }) => { 487 await load(page); 488 const result = await page.evaluate(async (role) => { 489 const f = window.hcp084Fixture, 490 s = window.hcp084; 491 if (role === 'pair') 492 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 493 const restore = f.loseReadback(); 494 const outcome = 495 role === 'self' 496 ? await s.prepareSelfRecovery( 497 f.preparation, 498 'reviewed_self_recovery' 499 ) 500 : await s.preparePairedDelivery( 501 f.preparation, 502 f.context, 503 'reviewed_pair_preparation' 504 ); 505 const state = s.privateComposerSnapshot(f.composer), 506 rebinding = s.bindPrivateComposerPreparation( 507 f.composer, 508 f.reserved, 509 f.preparation, 510 undefined, 511 'reviewed_composer_preparation' 512 ); 513 restore(); 514 s.stopSelfRecoveryPreparation(f.preparation); 515 const fresh = s.captureSelfRecoveryPreparation( 516 f.repository, 517 f.identity, 518 f.reserved, 519 'reviewed_self_recovery' 520 ); 521 if (!fresh) throw Error('fresh genuine controller missing'); 522 const freshBinding = s.bindPrivateComposerPreparation( 523 f.composer, 524 f.reserved, 525 fresh, 526 undefined, 527 'reviewed_composer_preparation' 528 ), 529 retired = s.privateComposerSnapshot(f.composer); 530 s.stopSelfRecoveryPreparation(fresh); 531 return { 532 outcome: outcome.status, 533 readbackFailures: f.readbackFailures(), 534 state: state?.state, 535 pair: state?.pairState, 536 dirty: state?.dirty, 537 rebinding, 538 freshBinding, 539 uncertaintyRetained: 540 retired?.state === state?.state && 541 retired?.pairState === state?.pairState, 542 original: s.privateComposerText(f.composer) === f.original, 543 ciphertext: !!(await f.storedPair()), 544 plaintext: (await f.stored()).includes(f.marker) 545 }; 546 }, role); 547 expect(result).toEqual( 548 role === 'self' 549 ? { 550 outcome: 'unknown_completion', 551 readbackFailures: 1, 552 state: 'unknown_completion', 553 pair: 'unprepared', 554 dirty: true, 555 rebinding: false, 556 freshBinding: false, 557 uncertaintyRetained: true, 558 original: true, 559 ciphertext: true, 560 plaintext: false 561 } 562 : { 563 outcome: 'unknown_completion', 564 readbackFailures: 1, 565 state: 'saved_encrypted', 566 pair: 'unknown_completion', 567 dirty: false, 568 rebinding: false, 569 freshBinding: false, 570 uncertaintyRetained: true, 571 original: true, 572 ciphertext: true, 573 plaintext: false 574 } 575 ); 576 } 577 ); 578 579 test('pair readback conflict cannot keep a prepared presentation from its prior genuine acknowledgement', async ({ 580 page 581 }) => { 582 await load(page); 583 const result = await page.evaluate(async () => { 584 const f = window.hcp084Fixture, 585 s = window.hcp084; 586 await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'); 587 await s.preparePairedDelivery( 588 f.preparation, 589 f.context, 590 'reviewed_pair_preparation' 591 ); 592 const before = s.privateComposerSnapshot(f.composer)?.pairState; 593 await f.changePairRevision(); 594 const bytes = await f.stored(); 595 const retry = await s.preparePairedDelivery( 596 f.preparation, 597 f.context, 598 'reviewed_pair_preparation' 599 ); 600 return { 601 before, 602 retry: retry.status, 603 after: s.privateComposerSnapshot(f.composer)?.pairState, 604 unchanged: bytes === (await f.stored()) 605 }; 606 }); 607 expect(result).toEqual({ 608 before: 'prepared', 609 retry: 'conflict', 610 after: 'needs_action', 611 unchanged: true 612 }); 613 });