envelope-preparation.spec.ts (13662B)
1 import { test, expect, 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 Pair from './harness/envelope-preparation.ts'; 6 declare global { 7 interface Window { 8 hcp078: typeof Pair; 9 hcp078Fixture: Awaited<ReturnType<typeof Pair.makeFixture>>; 10 hcp078Pair: NonNullable<ReturnType<typeof Pair.captureEnvelopePreparation>>; 11 hcp078Job: ReturnType<typeof Pair.prepareEnvelopeRole>; 12 } 13 } 14 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; 15 test.beforeAll(async () => { 16 server = await createStaticHarness(); 17 const result = await build({ 18 configFile: false, 19 logLevel: 'silent', 20 build: { 21 write: false, 22 minify: false, 23 lib: { 24 entry: fileURLToPath( 25 new URL('./harness/envelope-preparation.ts', import.meta.url) 26 ), 27 name: 'hcp078', 28 formats: ['iife'] 29 } 30 } 31 }); 32 const output = Array.isArray(result) ? result[0] : result; 33 if (!('output' in output)) throw Error('missing bundle'); 34 const chunks = output.output.filter((x) => x.type === 'chunk'); 35 expect(chunks).toHaveLength(1); 36 bundle = chunks[0].code; 37 }); 38 test.afterAll(async () => server.close()); 39 async function load(page: Page) { 40 await page.goto(server.url + '/search'); 41 await page.addScriptTag({ content: bundle }); 42 await page.evaluate(async () => { 43 const s = window.hcp078, 44 f = await s.makeFixture(); 45 window.hcp078Fixture = f; 46 const pair = s.captureEnvelopePreparation( 47 f.identity, 48 f.reserved, 49 'reviewed_envelope_pair' 50 ); 51 if (!pair) throw Error('missing pair'); 52 window.hcp078Pair = pair; 53 }); 54 } 55 test('self first and peer second decrypt to the same original, wrong routes and repeats spend no prompts', async ({ 56 page 57 }) => { 58 await load(page); 59 const result = await page.evaluate(async () => { 60 const s = window.hcp078, 61 f = window.hcp078Fixture, 62 p = window.hcp078Pair; 63 try { 64 const before = f.counts(); 65 const early = await s.prepareEnvelopeRole( 66 p, 67 'peer', 68 'reviewed_pair_role' 69 ), 70 wrong = await s.prepareEnvelopeRole(p, 'third', 'reviewed_pair_role'), 71 review = await s.prepareEnvelopeRole(p, 'self', 'wrong'); 72 const blockedUnchanged = 73 JSON.stringify(before) === JSON.stringify(f.counts()); 74 const first = await s.prepareEnvelopeRole( 75 p, 76 'self', 77 'reviewed_pair_role' 78 ), 79 prefix = s.envelopePreparationSnapshot(p); 80 if (!prefix?.self) throw Error('missing prefix'); 81 const afterSelf = f.counts(); 82 const second = await s.prepareEnvelopeRole( 83 p, 84 'peer', 85 'reviewed_pair_role' 86 ), 87 complete = s.envelopePreparationSnapshot(p); 88 if (!complete?.self || !complete.peer) throw Error('missing pair'); 89 const after = f.counts(); 90 const repeatedSelf = await s.prepareEnvelopeRole( 91 p, 92 'self', 93 'reviewed_pair_role' 94 ), 95 repeatedPeer = await s.prepareEnvelopeRole( 96 p, 97 'peer', 98 'reviewed_pair_role' 99 ); 100 const selfSeal = f.decryptWrap(complete.self.wire, 'self'), 101 peerSeal = f.decryptWrap(complete.peer.wire, 'peer'); 102 const selfOuter = JSON.parse(complete.self.wire) as { 103 id: string; 104 tags: string[][]; 105 }, 106 peerOuter = JSON.parse(complete.peer.wire) as { 107 id: string; 108 tags: string[][]; 109 }; 110 return { 111 early: early.status, 112 wrong: wrong.status, 113 review: review.status, 114 blockedUnchanged, 115 first: first.status, 116 phase: prefix.phase, 117 selfSigns: afterSelf.signs - before.signs, 118 selfEncrypts: afterSelf.encrypts - before.encrypts, 119 second: second.status, 120 complete: complete.phase, 121 samePrefix: prefix.self.wire === complete.self.wire, 122 sameRumor: complete.self.rumorHash === complete.peer.rumorHash, 123 selfEqual: f.decrypt(selfSeal, 'self').equal, 124 peerEqual: f.decrypt(peerSeal, 'peer').equal, 125 selfTags: selfOuter.tags, 126 peerTags: peerOuter.tags, 127 owner: f.owner, 128 peer: f.peer, 129 differentOuter: selfOuter.id !== peerOuter.id, 130 repeatedSelf: repeatedSelf.status, 131 repeatedPeer: repeatedPeer.status, 132 repeatedUnchanged: JSON.stringify(after) === JSON.stringify(f.counts()) 133 }; 134 } finally { 135 f.close(); 136 } 137 }); 138 expect(result).toMatchObject({ 139 early: 'out_of_order', 140 wrong: 'invalid', 141 review: 'invalid', 142 blockedUnchanged: true, 143 first: 'prepared', 144 phase: 'peer', 145 selfSigns: 1, 146 selfEncrypts: 1, 147 second: 'complete', 148 complete: 'complete', 149 samePrefix: true, 150 sameRumor: true, 151 selfEqual: true, 152 peerEqual: true, 153 differentOuter: true, 154 repeatedSelf: 'complete', 155 repeatedPeer: 'complete', 156 repeatedUnchanged: true 157 }); 158 expect(result.selfTags).toEqual([['p', result.owner]]); 159 expect(result.peerTags).toEqual([['p', result.peer]]); 160 }); 161 test('peer refusal preserves the exact self proof and only explicit retry resumes the original pair', async ({ 162 page 163 }) => { 164 await load(page); 165 const result = await page.evaluate(async () => { 166 const s = window.hcp078, 167 f = window.hcp078Fixture, 168 p = window.hcp078Pair; 169 try { 170 await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role'); 171 const prefix = s.envelopePreparationSnapshot(p), 172 proof = s.preparedEnvelopeProof(p, 'self'); 173 f.mode('declined'); 174 const failed = await s.prepareEnvelopeRole( 175 p, 176 'peer', 177 'reviewed_pair_role' 178 ), 179 paused = s.envelopePreparationSnapshot(p), 180 counts = f.counts(); 181 f.mode('normal'); 182 const retried = await s.prepareEnvelopeRole( 183 p, 184 'peer', 185 'reviewed_pair_role' 186 ), 187 done = s.envelopePreparationSnapshot(p); 188 if (!done?.self || !done.peer) throw Error('missing completed pair'); 189 return { 190 failed: failed.status, 191 phase: paused?.phase, 192 busy: paused?.busy, 193 unchanged: 194 prefix?.self?.wire === paused?.self?.wire && 195 paused?.self?.wire === done.self.wire, 196 sameProof: proof === s.preparedEnvelopeProof(p, 'self'), 197 retry: retried.status, 198 retrySigns: f.counts().signs - counts.signs, 199 retryEncrypts: f.counts().encrypts - counts.encrypts, 200 selfEqual: f.decrypt(f.decryptWrap(done.self.wire, 'self'), 'self') 201 .equal, 202 peerEqual: f.decrypt(f.decryptWrap(done.peer.wire, 'peer'), 'peer') 203 .equal 204 }; 205 } finally { 206 f.close(); 207 } 208 }); 209 expect(result).toEqual({ 210 failed: 'refused', 211 phase: 'peer', 212 busy: false, 213 unchanged: true, 214 sameProof: true, 215 retry: 'complete', 216 retrySigns: 1, 217 retryEncrypts: 1, 218 selfEqual: true, 219 peerEqual: true 220 }); 221 }); 222 for (const action of ['stop', 'expire'] as const) 223 test(`${action} pending peer keeps admission and real lock until settlement and preserves completed self`, async ({ 224 page 225 }) => { 226 await load(page); 227 const prefix = await page.evaluate(async () => { 228 const s = window.hcp078, 229 f = window.hcp078Fixture, 230 p = window.hcp078Pair; 231 await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role'); 232 const wire = s.envelopePreparationSnapshot(p)?.self?.wire; 233 f.mode('hold_decrypt'); 234 window.hcp078Job = s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role'); 235 return wire; 236 }); 237 await expect 238 .poll(() => page.evaluate(() => window.hcp078Fixture.slot())) 239 .toMatchObject({ state: 'active', pending: 'decrypt' }); 240 const pending = await page.evaluate(async (action) => { 241 const s = window.hcp078, 242 f = window.hcp078Fixture, 243 p = window.hcp078Pair; 244 if (action === 'expire') s.expireEnvelopePreparationWait(p); 245 else s.stopEnvelopePreparation(p); 246 const contender = f.operation(); 247 if (!contender) throw Error('missing contender'); 248 return { 249 busy: s.envelopePreparationSnapshot(p)?.busy, 250 pairBusy: (await s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role')) 251 .status, 252 lockBusy: (await s.buildPrivateSeal(contender)).status, 253 slot: f.slot(), 254 wire: s.envelopePreparationSnapshot(p)?.self?.wire 255 }; 256 }, action); 257 expect(pending).toMatchObject({ 258 busy: true, 259 pairBusy: 'busy', 260 lockBusy: 'busy', 261 slot: { state: 'active', pending: 'decrypt' }, 262 wire: prefix 263 }); 264 const settled = await page.evaluate(async () => { 265 const s = window.hcp078, 266 f = window.hcp078Fixture, 267 p = window.hcp078Pair, 268 before = f.counts(); 269 try { 270 f.settle(); 271 const stopped = await window.hcp078Job, 272 paused = s.envelopePreparationSnapshot(p), 273 noLate = JSON.stringify(before) === JSON.stringify(f.counts()); 274 f.mode('normal'); 275 const result = await s.prepareEnvelopeRole( 276 p, 277 'peer', 278 'reviewed_pair_role' 279 ), 280 done = s.envelopePreparationSnapshot(p); 281 return { 282 status: stopped.status, 283 phase: paused?.phase, 284 busy: paused?.busy, 285 wire: paused?.self?.wire, 286 noLate, 287 slot: f.slot(), 288 resumed: result.status, 289 sameSelf: done?.self?.wire === paused?.self?.wire 290 }; 291 } finally { 292 f.close(); 293 } 294 }); 295 expect(settled).toEqual({ 296 status: 'stopped', 297 phase: 'peer', 298 busy: false, 299 wire: prefix, 300 noLate: true, 301 slot: { state: 'idle' }, 302 resumed: 'complete', 303 sameSelf: true 304 }); 305 }); 306 for (const action of ['close', 'disconnect'] as const) 307 test(`${action} retires prefix and pending peer permanently without releasing unsettled work early`, async ({ 308 page 309 }) => { 310 await load(page); 311 await page.evaluate(async () => { 312 const s = window.hcp078, 313 f = window.hcp078Fixture, 314 p = window.hcp078Pair; 315 await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role'); 316 f.mode('hold_decrypt'); 317 window.hcp078Job = s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role'); 318 }); 319 await expect 320 .poll(() => page.evaluate(() => window.hcp078Fixture.slot())) 321 .toMatchObject({ state: 'active', pending: 'decrypt' }); 322 const pending = await page.evaluate((action) => { 323 const s = window.hcp078, 324 f = window.hcp078Fixture, 325 p = window.hcp078Pair; 326 if (action === 'close') { 327 s.closeEnvelopePreparation(p); 328 s.closeEnvelopePreparation(p); 329 } else f.disconnect(); 330 return { 331 retired: !s.envelopePreparationSnapshot(p), 332 proofGone: !s.preparedEnvelopeProof(p, 'self'), 333 slot: f.slot() 334 }; 335 }, action); 336 expect(pending).toEqual({ 337 retired: true, 338 proofGone: true, 339 slot: { state: 'active', pending: 'decrypt', phase: 'stopped' } 340 }); 341 const settled = await page.evaluate(async (action) => { 342 const s = window.hcp078, 343 f = window.hcp078Fixture, 344 p = window.hcp078Pair, 345 before = f.counts(); 346 try { 347 f.settle(); 348 const result = await window.hcp078Job, 349 noLate = JSON.stringify(before) === JSON.stringify(f.counts()); 350 f.mode('normal'); 351 if (action === 'disconnect') { 352 await s.connectIdentity(f.identity); 353 await s.probeIdentityMessaging(f.identity, 'reviewed_self_copy'); 354 } 355 return { 356 status: result.status, 357 noLate, 358 slot: f.slot(), 359 oldRetired: !s.envelopePreparationSnapshot(p), 360 retry: (await s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role')) 361 .status 362 }; 363 } finally { 364 f.close(); 365 } 366 }, action); 367 expect(settled).toEqual({ 368 status: 'stopped', 369 noLate: true, 370 slot: { state: 'idle' }, 371 oldRetired: true, 372 retry: 'stopped' 373 }); 374 }); 375 test('detached snapshots and cast reservations cannot become another preparation controller', async ({ 376 page 377 }) => { 378 await load(page); 379 const result = await page.evaluate(async () => { 380 const s = window.hcp078, 381 f = window.hcp078Fixture, 382 p = window.hcp078Pair; 383 try { 384 await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role'); 385 const observed = s.envelopePreparationSnapshot(p); 386 if (!observed) throw Error('missing snapshot'); 387 const cast = observed as unknown as typeof p, 388 second = await f.reserveAgain(); 389 const other = s.captureEnvelopePreparation( 390 f.identity, 391 second, 392 'reviewed_envelope_pair' 393 ); 394 return { 395 cast: (await s.prepareEnvelopeRole(cast, 'peer', 'reviewed_pair_role')) 396 .status, 397 detached: !s.captureEnvelopePreparation( 398 f.identity, 399 {} as typeof f.reserved, 400 'reviewed_envelope_pair' 401 ), 402 sameReservation: second === f.reserved, 403 newPair: !!other, 404 newPairHasNoPrefix: !!other && !s.preparedEnvelopeProof(other, 'self'), 405 originalPrefix: !!s.preparedEnvelopeProof(p, 'self') 406 }; 407 } finally { 408 f.close(); 409 } 410 }); 411 expect(result).toEqual({ 412 cast: 'invalid', 413 detached: true, 414 sameReservation: false, 415 newPair: true, 416 newPairHasNoPrefix: true, 417 originalPrefix: true 418 }); 419 });