drafts.spec.ts (18252B)
1 import { expect, test, type Page } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { createHash } from 'node:crypto'; 4 import { fileURLToPath } from 'node:url'; 5 import { createStaticHarness } from '../integration/harness/static.ts'; 6 import type * as Database from '../../src/lib/persistence/database.ts'; 7 import type * as Drafts from '../../src/lib/persistence/drafts.ts'; 8 declare global { 9 interface Window { 10 hcp047: typeof Database & typeof Drafts; 11 hcp047Database: Database.BrowserDatabase; 12 hcp047Repository: Drafts.PublicDraftRepository; 13 } 14 } 15 const owner = 16 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 17 const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; 18 const form = { 19 title: '', 20 description: 'unfinished', 21 location: '', 22 amount: '.', 23 currency: '', 24 unit: '', 25 quantity: '', 26 contactType: '' as const, 27 contactValue: '' 28 }; 29 let server: Awaited<ReturnType<typeof createStaticHarness>>; 30 let bundle: string; 31 test.beforeAll(async () => { 32 server = await createStaticHarness(); 33 const source = (name: string) => 34 fileURLToPath( 35 new URL('../../src/lib/persistence/' + name, import.meta.url) 36 ); 37 // Compile the exact current production modules together so both use the same 38 // genuine WeakMap database ownership. This virtual entry is test-only. 39 const result = await build({ 40 configFile: false, 41 logLevel: 'silent', 42 plugins: [ 43 { 44 name: 'hcp047-test-entry', 45 resolveId(id) { 46 if (id === 'virtual:hcp047') return '\0hcp047'; 47 }, 48 load(id) { 49 if (id === '\0hcp047') 50 return `export * from ${JSON.stringify(source('database.ts'))};export * from ${JSON.stringify(source('drafts.ts'))};`; 51 } 52 } 53 ], 54 build: { 55 write: false, 56 minify: false, 57 rolldownOptions: { input: 'virtual:hcp047' }, 58 lib: { entry: 'virtual:hcp047', name: 'hcp047', formats: ['iife'] } 59 } 60 }); 61 const output = Array.isArray(result) ? result[0] : result; 62 if (!('output' in output)) throw new Error('missing test bundle'); 63 const chunks = output.output.filter((item) => item.type === 'chunk'); 64 expect(chunks).toHaveLength(1); 65 bundle = chunks[0].code; 66 console.log( 67 JSON.stringify({ 68 fixture: 'HCP047_ACTUAL_MODULES_REAL_IDB', 69 bundleSha256: createHash('sha256').update(bundle).digest('hex'), 70 exposure: 'test-only virtual entry, no production route or dependency' 71 }) 72 ); 73 }); 74 test.afterAll(async () => server.close()); 75 async function load(page: Page, selectedOwner = owner) { 76 await page.goto(server.url + '/search'); 77 await page.addScriptTag({ content: bundle }); 78 await page.evaluate(async (expectedOwner) => { 79 const api = window.hcp047; 80 const opened = await api.openBrowserDatabase(); 81 if (opened.state !== 'ready') throw new Error(opened.reason); 82 const repository = api.createPublicDraftRepository( 83 opened.owner, 84 expectedOwner 85 ); 86 if (!repository) throw new Error('missing repository'); 87 window.hcp047Database = opened.owner; 88 window.hcp047Repository = repository; 89 }, selectedOwner); 90 } 91 test('guest GET and module initialization create no database; explicit create retains partial strings and detached snapshots', async ({ 92 page 93 }) => { 94 await page.goto(server.url + '/search'); 95 await page.addScriptTag({ content: bundle }); 96 expect( 97 await page.evaluate(async () => (await indexedDB.databases()).length) 98 ).toBe(0); 99 await load(page); 100 const result = await page.evaluate(async (input) => { 101 const api = window.hcp047, 102 repository = window.hcp047Repository; 103 const created = await api.createPublicDraft(repository, input); 104 if (!created.ok) throw new Error(created.reason); 105 const id = created.value.id; 106 const original = JSON.stringify(created.value); 107 // Detached output mutation never edits the actual committed wire. 108 const mutable = created.value as { form: { amount: string } }; 109 mutable.form.amount = 'other'; 110 const read = await api.readPublicDraft(repository, id); 111 const listed = await api.listPublicDrafts(repository); 112 api.closeBrowserDatabase(window.hcp047Database); 113 const reopened = await api.openBrowserDatabase(); 114 if (reopened.state !== 'ready') throw new Error(reopened.reason); 115 const next = api.createPublicDraftRepository( 116 reopened.owner, 117 created.value.owner 118 ); 119 if (!next) throw new Error('missing reopened scope'); 120 const retained = await api.readPublicDraft(next, id); 121 api.closeBrowserDatabase(reopened.owner); 122 return { 123 created: { 124 ok: true as const, 125 value: JSON.parse(original) as typeof created.value 126 }, 127 read, 128 listed, 129 retained 130 }; 131 }, form); 132 expect(result.created.ok).toBe(true); 133 expect(result.created.value.form).toEqual(form); 134 expect(result.created.value.revision).toBe(0); 135 expect(result.created.value.id).toMatch( 136 /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/ 137 ); 138 expect(result.read).toEqual(result.created); 139 expect(result.retained).toEqual(result.created); 140 expect(result.listed).toEqual({ ok: true, value: [result.created.value] }); 141 }); 142 test('two actual tabs serialize competing revision CAS and preserve the winning incomplete form', async ({ 143 page, 144 context 145 }) => { 146 await load(page); 147 const second = await context.newPage(); 148 await load(second); 149 const created = await page.evaluate( 150 async (input) => 151 window.hcp047.createPublicDraft(window.hcp047Repository, input), 152 form 153 ); 154 if (!created.ok) throw new Error(created.reason); 155 const id = created.value.id; 156 const saves = await Promise.all( 157 [page, second].map((tab, index) => 158 tab.evaluate( 159 async ({ id, form }) => 160 window.hcp047.savePublicDraft(window.hcp047Repository, id, 0, form), 161 { 162 id, 163 form: { 164 ...form, 165 location: index === 0 ? 'unfinished north' : 'unfinished south', 166 amount: '1.' 167 } 168 } 169 ) 170 ) 171 ); 172 expect(saves.filter((save) => save.ok)).toHaveLength(1); 173 expect(saves.filter((save) => !save.ok)).toEqual([ 174 { ok: false, reason: 'conflict' } 175 ]); 176 const winner = saves.find((save) => save.ok); 177 const read = await second.evaluate( 178 async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id), 179 id 180 ); 181 expect(read).toEqual(winner); 182 if (!read.ok) throw new Error(read.reason); 183 expect(read.value.revision).toBe(1); 184 expect(read.value.form.amount).toBe('1.'); 185 await second.close(); 186 }); 187 test('two tabs race the last owner slot and cap refusal preserves every existing draft', async ({ 188 page, 189 context 190 }) => { 191 await load(page); 192 const initial = await page.evaluate(async (form) => { 193 const rows = []; 194 for (let i = 0; i < 19; i++) 195 rows.push( 196 await window.hcp047.createPublicDraft(window.hcp047Repository, form) 197 ); 198 return rows; 199 }, form); 200 expect(initial.every((row) => row.ok)).toBe(true); 201 const second = await context.newPage(); 202 await load(second); 203 const raced = await Promise.all( 204 [page, second].map((tab) => 205 tab.evaluate( 206 async (form) => 207 window.hcp047.createPublicDraft(window.hcp047Repository, form), 208 form 209 ) 210 ) 211 ); 212 expect(raced.filter((row) => row.ok)).toHaveLength(1); 213 expect(raced.filter((row) => !row.ok)).toEqual([ 214 { ok: false, reason: 'cap_reached' } 215 ]); 216 const after = await page.evaluate(async () => 217 window.hcp047.listPublicDrafts(window.hcp047Repository) 218 ); 219 if (!after.ok) throw new Error(after.reason); 220 expect(after.value).toHaveLength(20); 221 for (const row of initial) { 222 if (!row.ok) throw new Error(row.reason); 223 expect(after.value.find((stored) => stored.id === row.value.id)).toEqual( 224 row.value 225 ); 226 } 227 const separate = await second.evaluate( 228 async ({ peer, form }) => { 229 const repo = window.hcp047.createPublicDraftRepository( 230 window.hcp047Database, 231 peer 232 ); 233 if (!repo) throw new Error('missing peer namespace'); 234 return window.hcp047.createPublicDraft(repo, form); 235 }, 236 { peer, form } 237 ); 238 expect(separate.ok).toBe(true); 239 await second.close(); 240 }); 241 test('16KiB composed UTF8 inclusive admission, malformed getters and oversized update preserve the previous draft', async ({ 242 page 243 }) => { 244 await load(page); 245 const result = await page.evaluate(async (input) => { 246 const api = window.hcp047, 247 repository = window.hcp047Repository; 248 const bounded = { ...input, description: '菜'.repeat(5461), amount: 'x' }; 249 const created = await api.createPublicDraft(repository, bounded); 250 if (!created.ok) throw new Error(created.reason); 251 const overflow = await api.savePublicDraft( 252 repository, 253 created.value.id, 254 0, 255 { ...bounded, title: 'x' } 256 ); 257 const getter = await api.savePublicDraft(repository, created.value.id, 0, { 258 ...bounded, 259 get title() { 260 throw new Error('must not acquire getter'); 261 } 262 }); 263 const badRevision = await api.savePublicDraft( 264 repository, 265 created.value.id, 266 Number.MAX_SAFE_INTEGER, 267 input 268 ); 269 const proxy = await api.savePublicDraft( 270 repository, 271 created.value.id, 272 0, 273 new Proxy(input, { 274 ownKeys() { 275 throw new Error('hostile proxy'); 276 } 277 }) 278 ); 279 let titleReads = 0, 280 coercions = 0; 281 const changingCreated = await api.createPublicDraft( 282 repository, 283 new Proxy(input, { 284 get(target, property, receiver): unknown { 285 if (property === 'title') { 286 titleReads++; 287 if (titleReads === 1) return 'captured-once'; 288 return { 289 length: 0, 290 isWellFormed() { 291 coercions++; 292 return true; 293 }, 294 toString() { 295 coercions++; 296 return ''; 297 }, 298 toJSON() { 299 coercions++; 300 return ''; 301 } 302 }; 303 } 304 return Reflect.get(target, property, receiver); 305 } 306 }) 307 ); 308 const read = await api.readPublicDraft(repository, created.value.id); 309 return { 310 created, 311 overflow, 312 getter, 313 badRevision, 314 proxy, 315 changingCreated, 316 titleReads, 317 coercions, 318 read 319 }; 320 }, form); 321 expect(result.overflow).toEqual({ ok: false, reason: 'invalid_form' }); 322 expect(result.getter).toEqual({ ok: false, reason: 'invalid_form' }); 323 expect(result.badRevision).toEqual({ ok: false, reason: 'invalid_revision' }); 324 expect(result.proxy).toEqual({ ok: false, reason: 'invalid_form' }); 325 expect(result.titleReads).toBe(1); 326 expect(result.coercions).toBe(0); 327 if (!result.changingCreated.ok) 328 throw new Error(result.changingCreated.reason); 329 expect(result.changingCreated.value.form.title).toBe('captured-once'); 330 expect(result.read).toEqual(result.created); 331 }); 332 test('foreign owner cannot read/update/list a draft, and its own cap is independent', async ({ 333 page, 334 context 335 }) => { 336 await load(page); 337 const created = await page.evaluate( 338 async (form) => 339 window.hcp047.createPublicDraft(window.hcp047Repository, form), 340 form 341 ); 342 if (!created.ok) throw new Error(created.reason); 343 const second = await context.newPage(); 344 await load(second, peer); 345 const foreign = await second.evaluate( 346 async ({ id, form }) => ({ 347 read: await window.hcp047.readPublicDraft(window.hcp047Repository, id), 348 save: await window.hcp047.savePublicDraft( 349 window.hcp047Repository, 350 id, 351 0, 352 form 353 ), 354 list: await window.hcp047.listPublicDrafts(window.hcp047Repository), 355 create: await window.hcp047.createPublicDraft( 356 window.hcp047Repository, 357 form 358 ) 359 }), 360 { id: created.value.id, form } 361 ); 362 expect(foreign.read).toEqual({ ok: false, reason: 'not_found' }); 363 expect(foreign.save).toEqual({ ok: false, reason: 'not_found' }); 364 expect(foreign.list).toEqual({ ok: true, value: [] }); 365 expect(foreign.create.ok).toBe(true); 366 expect( 367 await page.evaluate( 368 async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id), 369 created.value.id 370 ) 371 ).toEqual(created); 372 await second.close(); 373 }); 374 test('malformed persisted schema aborts reads and updates without overwriting its bytes', async ({ 375 page 376 }) => { 377 await load(page); 378 const result = await page.evaluate(async (form) => { 379 const api = window.hcp047, 380 repo = window.hcp047Repository; 381 const created = await api.createPublicDraft(repo, form); 382 if (!created.ok) throw new Error(created.reason); 383 const corruptWire = JSON.stringify({ ...created.value, schema: 2 }); 384 const tx = api.browserDatabaseTransaction( 385 window.hcp047Database, 386 ['public_drafts'], 387 'readwrite' 388 ); 389 tx.objectStore('public_drafts').put({ 390 owner: created.value.owner, 391 id: created.value.id, 392 wire: corruptWire 393 }); 394 await new Promise<void>((resolve, reject) => { 395 tx.addEventListener('complete', () => resolve()); 396 tx.addEventListener('abort', () => reject(new Error('fixture abort'))); 397 }); 398 const read = await api.readPublicDraft(repo, created.value.id); 399 const save = await api.savePublicDraft(repo, created.value.id, 0, form); 400 const list = await api.listPublicDrafts(repo); 401 const check = api.browserDatabaseTransaction( 402 window.hcp047Database, 403 ['public_drafts'], 404 'readonly' 405 ); 406 const request = check 407 .objectStore('public_drafts') 408 .get([created.value.owner, created.value.id]); 409 const wire = await new Promise<unknown>((resolve) => 410 request.addEventListener('success', () => { 411 const value: unknown = request.result; 412 resolve( 413 typeof value === 'object' && value !== null && 'wire' in value 414 ? value.wire 415 : undefined 416 ); 417 }) 418 ); 419 return { read, save, list, wire, corruptWire }; 420 }, form); 421 expect(result.read).toEqual({ ok: false, reason: 'corrupt_record' }); 422 expect(result.save).toEqual(result.read); 423 expect(result.list).toEqual(result.read); 424 expect(result.wire).toBe(result.corruptWire); 425 }); 426 test('actual transaction abort after successful put never acknowledges or retains a draft', async ({ 427 page 428 }) => { 429 await load(page); 430 const result = await page.evaluate(async (form) => { 431 const api = window.hcp047, 432 repo = window.hcp047Repository; 433 const descriptor = Object.getOwnPropertyDescriptor( 434 IDBObjectStore.prototype, 435 'put' 436 ); 437 if (!descriptor) throw new Error('missing put descriptor'); 438 const original = descriptor.value as IDBObjectStore['put']; 439 IDBObjectStore.prototype.put = function (...args) { 440 const request = original.apply(this, args); 441 const transaction = this.transaction; 442 request.addEventListener('success', () => transaction.abort()); 443 return request; 444 }; 445 try { 446 const create = await api.createPublicDraft(repo, form); 447 const list = await api.listPublicDrafts(repo); 448 return { create, list }; 449 } finally { 450 IDBObjectStore.prototype.put = original; 451 } 452 }, form); 453 expect(result.create).toEqual({ ok: false, reason: 'aborted' }); 454 expect(result.list).toEqual({ ok: true, value: [] }); 455 }); 456 test('closed database scope rejects later writes and never silently reopens', async ({ 457 page 458 }) => { 459 await load(page); 460 const result = await page.evaluate(async (form) => { 461 window.hcp047.closeBrowserDatabase(window.hcp047Database); 462 return window.hcp047.createPublicDraft(window.hcp047Repository, form); 463 }, form); 464 expect(result).toEqual({ ok: false, reason: 'invalid_scope' }); 465 }); 466 467 test('explicit draft changes acquire only the public draft store and make no fetch or socket attempt', async ({ 468 page 469 }) => { 470 await load(page); 471 const result = await page.evaluate(async (form) => { 472 const transactionDescriptor = Object.getOwnPropertyDescriptor( 473 IDBDatabase.prototype, 474 'transaction' 475 ); 476 const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch'); 477 const socketDescriptor = Object.getOwnPropertyDescriptor( 478 window, 479 'WebSocket' 480 ); 481 if (!transactionDescriptor || !fetchDescriptor || !socketDescriptor) 482 throw new Error('missing native descriptors'); 483 const transaction = 484 transactionDescriptor.value as IDBDatabase['transaction']; 485 const selected: string[][] = []; 486 let effects = 0; 487 IDBDatabase.prototype.transaction = function (...args) { 488 selected.push( 489 typeof args[0] === 'string' ? [args[0]] : Array.from(args[0]) 490 ); 491 return transaction.apply(this, args); 492 }; 493 Object.defineProperty(window, 'fetch', { 494 configurable: true, 495 value: () => { 496 effects++; 497 throw new Error('unexpected fetch'); 498 } 499 }); 500 Object.defineProperty(window, 'WebSocket', { 501 configurable: true, 502 value: class { 503 constructor() { 504 effects++; 505 throw new Error('unexpected socket'); 506 } 507 } 508 }); 509 try { 510 const api = window.hcp047, 511 repo = window.hcp047Repository; 512 const created = await api.createPublicDraft(repo, form); 513 if (!created.ok) throw new Error(created.reason); 514 const saved = await api.savePublicDraft(repo, created.value.id, 0, { 515 ...form, 516 amount: '1.' 517 }); 518 if (!saved.ok) throw new Error(saved.reason); 519 const read = await api.readPublicDraft(repo, created.value.id); 520 const list = await api.listPublicDrafts(repo); 521 return { saved, read, list, selected, effects }; 522 } finally { 523 Object.defineProperty( 524 IDBDatabase.prototype, 525 'transaction', 526 transactionDescriptor 527 ); 528 Object.defineProperty(window, 'fetch', fetchDescriptor); 529 Object.defineProperty(window, 'WebSocket', socketDescriptor); 530 } 531 }, form); 532 expect(result.read).toEqual(result.saved); 533 expect(result.list.ok).toBe(true); 534 expect(result.effects).toBe(0); 535 expect(result.selected).toEqual( 536 Array.from({ length: 4 }, () => ['public_drafts']) 537 ); 538 });