draft-controller.spec.ts (12674B)
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 Controller from '../../src/lib/publishing/draft-controller.ts'; 8 import type * as Drafts from '../../src/lib/persistence/drafts.ts'; 9 declare global { 10 interface Window { 11 hcp048: typeof Database & typeof Drafts & typeof Controller; 12 hcp048Database: Database.BrowserDatabase; 13 hcp048Repository: Drafts.PublicDraftRepository; 14 } 15 } 16 const owner = 17 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 18 const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; 19 const form = { 20 title: '', 21 description: 'unfinished', 22 location: '', 23 amount: '.', 24 currency: '', 25 unit: '', 26 quantity: '', 27 contactType: '' as const, 28 contactValue: '' 29 }; 30 let server: Awaited<ReturnType<typeof createStaticHarness>>; 31 let bundle: string; 32 test.beforeAll(async () => { 33 server = await createStaticHarness(); 34 const source = (name: string) => 35 fileURLToPath( 36 new URL('../../src/lib/persistence/' + name, import.meta.url) 37 ); 38 // Compile the exact current production modules together so both use the same 39 // genuine WeakMap database ownership. This virtual entry is test-only. 40 const result = await build({ 41 configFile: false, 42 logLevel: 'silent', 43 plugins: [ 44 { 45 name: 'hcp048-test-entry', 46 resolveId(id) { 47 if (id === 'virtual:hcp048') return '\0hcp048'; 48 }, 49 load(id) { 50 if (id === '\0hcp048') 51 return `export * from ${JSON.stringify(source('database.ts'))};export * from ${JSON.stringify(source('drafts.ts'))};export * from ${JSON.stringify(source('../publishing/draft-controller.ts'))};`; 52 } 53 } 54 ], 55 build: { 56 write: false, 57 minify: false, 58 rolldownOptions: { input: 'virtual:hcp048' }, 59 lib: { entry: 'virtual:hcp048', name: 'hcp048', formats: ['iife'] } 60 } 61 }); 62 const output = Array.isArray(result) ? result[0] : result; 63 if (!('output' in output)) throw new Error('missing test bundle'); 64 const chunks = output.output.filter((item) => item.type === 'chunk'); 65 expect(chunks).toHaveLength(1); 66 bundle = chunks[0].code; 67 console.log( 68 JSON.stringify({ 69 fixture: 'HCP048_ACTUAL_MODULES_REAL_IDB', 70 bundleSha256: createHash('sha256').update(bundle).digest('hex'), 71 exposure: 'test-only virtual entry, no production route or dependency' 72 }) 73 ); 74 }); 75 test.afterAll(async () => server.close()); 76 async function load(page: Page, selectedOwner = owner) { 77 await page.goto(server.url + '/search'); 78 await page.addScriptTag({ content: bundle }); 79 await page.evaluate(async (expectedOwner) => { 80 const api = window.hcp048; 81 const opened = await api.openBrowserDatabase(); 82 if (opened.state !== 'ready') throw new Error(opened.reason); 83 const repository = api.createPublicDraftRepository( 84 opened.owner, 85 expectedOwner 86 ); 87 if (!repository) throw new Error('missing repository'); 88 window.hcp048Database = opened.owner; 89 window.hcp048Repository = repository; 90 }, selectedOwner); 91 } 92 test('immutable capture replays the exact committed ID/time/form once and denies foreign handles', async ({ 93 page 94 }) => { 95 await load(page); 96 const result = await page.evaluate( 97 async ({ form, peer }) => { 98 const api = window.hcp048, 99 repository = window.hcp048Repository; 100 const captured = api.capturePublicDraftCreate(repository, form); 101 if (!captured.ok) throw new Error(captured.reason); 102 const before = api.publicDraftWriteSnapshot(repository, captured.value); 103 if (!before) throw new Error('missing snapshot'); 104 const immutable = JSON.stringify(before); 105 const mutable = before.form as { title: string }; 106 mutable.title = 'foreign'; 107 const absent = await api.observePublicDraftWrite( 108 repository, 109 captured.value 110 ); 111 const first = await api.commitPublicDraftWrite( 112 repository, 113 captured.value 114 ); 115 const replay = await api.commitPublicDraftWrite( 116 repository, 117 captured.value 118 ); 119 const observed = await api.observePublicDraftWrite( 120 repository, 121 captured.value 122 ); 123 const other = api.createPublicDraftRepository( 124 window.hcp048Database, 125 peer 126 ); 127 if (!other) throw new Error('missing foreign namespace'); 128 const foreign = await api.commitPublicDraftWrite(other, captured.value); 129 const rows = await api.listPublicDrafts(repository); 130 return { immutable, absent, first, replay, observed, foreign, rows }; 131 }, 132 { form, peer } 133 ); 134 expect(result.absent).toEqual({ state: 'base_observed' }); 135 expect(result.first).toEqual({ 136 ok: true, 137 value: JSON.parse( 138 result.immutable 139 ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord 140 }); 141 expect(result.replay).toEqual(result.first); 142 expect(result.observed).toEqual({ 143 state: 'committed', 144 value: JSON.parse( 145 result.immutable 146 ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord 147 }); 148 expect(result.foreign).toEqual({ ok: false, reason: 'invalid_scope' }); 149 expect(result.rows).toEqual({ 150 ok: true, 151 value: [ 152 JSON.parse( 153 result.immutable 154 ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord 155 ] 156 }); 157 }); 158 test('genuine autosave coalesces pending edits, resumes durable input, and flushes before save-close', async ({ 159 page 160 }) => { 161 await load(page); 162 const result = await page.evaluate(async (form) => { 163 const api = window.hcp048, 164 repository = window.hcp048Repository; 165 const controller = await api.createPublicDraftController(repository, form); 166 if (!controller) throw new Error('missing controller'); 167 api.editPublicDraft(controller, { ...form, title: 'first' }); 168 api.editPublicDraft(controller, { ...form, title: 'latest', amount: '1.' }); 169 const flushed = await api.flushPublicDraft(controller); 170 const saved = api.publicDraftControllerSnapshot(controller); 171 if (!saved?.draft) throw new Error('missing saved draft'); 172 const resumed = await api.createPublicDraftController( 173 repository, 174 form, 175 saved.draft.id 176 ); 177 if (!resumed) throw new Error('missing resumed controller'); 178 api.editPublicDraft(resumed, { 179 ...saved.form, 180 description: 'newer partial' 181 }); 182 const closed = await api.saveAndClosePublicDraft(resumed); 183 const final = api.publicDraftControllerSnapshot(resumed); 184 const retained = await api.readPublicDraft(repository, saved.draft.id); 185 const late = api.editPublicDraft(resumed, form); 186 return { flushed, saved, closed, final, retained, late }; 187 }, form); 188 expect(result.flushed).toBe(true); 189 expect(result.saved).toMatchObject({ 190 state: 'saved', 191 editVersion: 2, 192 savedEditVersion: 2, 193 draft: { revision: 0 }, 194 form: { title: 'latest', amount: '1.' } 195 }); 196 expect(result.closed).toBe(true); 197 expect(result.final).toMatchObject({ 198 state: 'closed', 199 draft: { revision: 1, form: { description: 'newer partial' } } 200 }); 201 expect(result.retained).toEqual({ ok: true, value: result.final?.draft }); 202 expect(result.late).toBe(false); 203 }); 204 test('owner capacity refusal retains dirty input and prevents save-close without deleting drafts', async ({ 205 page 206 }) => { 207 await load(page); 208 const result = await page.evaluate(async (form) => { 209 const api = window.hcp048, 210 repository = window.hcp048Repository; 211 for (let i = 0; i < 20; i++) { 212 const created = await api.createPublicDraft(repository, form); 213 if (!created.ok) throw new Error(created.reason); 214 } 215 const controller = await api.createPublicDraftController(repository, form); 216 if (!controller) throw new Error('missing controller'); 217 api.editPublicDraft(controller, { ...form, title: 'retain dirty input' }); 218 const closed = await api.saveAndClosePublicDraft(controller); 219 const snapshot = api.publicDraftControllerSnapshot(controller); 220 const rows = await api.listPublicDrafts(repository); 221 return { closed, snapshot, count: rows.ok ? rows.value.length : -1 }; 222 }, form); 223 expect(result.closed).toBe(false); 224 expect(result.snapshot).toMatchObject({ 225 state: 'failed', 226 failure: 'cap_reached', 227 form: { title: 'retain dirty input' }, 228 savedEditVersion: -1, 229 draft: null 230 }); 231 expect(result.count).toBe(20); 232 }); 233 test('an advanced competing revision conflicts with the original capture and keeps the current input', async ({ 234 page 235 }) => { 236 await load(page); 237 const result = await page.evaluate(async (form) => { 238 const api = window.hcp048, 239 repository = window.hcp048Repository; 240 const created = await api.createPublicDraft(repository, form); 241 if (!created.ok) throw new Error(created.reason); 242 const capture = api.capturePublicDraftSave( 243 repository, 244 created.value.id, 245 0, 246 { ...form, title: 'attempted' } 247 ); 248 if (!capture.ok) throw new Error(capture.reason); 249 const competitor = await api.savePublicDraft( 250 repository, 251 created.value.id, 252 0, 253 { ...form, title: 'competitor' } 254 ); 255 const observed = await api.observePublicDraftWrite( 256 repository, 257 capture.value 258 ); 259 const commit = await api.commitPublicDraftWrite(repository, capture.value); 260 const retained = await api.readPublicDraft(repository, created.value.id); 261 return { competitor, observed, commit, retained }; 262 }, form); 263 expect(result.competitor.ok).toBe(true); 264 expect(result.observed).toEqual({ state: 'conflict' }); 265 expect(result.commit).toEqual({ ok: false, reason: 'conflict' }); 266 expect(result.retained).toEqual(result.competitor); 267 }); 268 test('private-shaped input is denied and closing the database invalidates genuine captures and workers', async ({ 269 page 270 }) => { 271 await load(page); 272 const result = await page.evaluate(async (form) => { 273 const api = window.hcp048, 274 repository = window.hcp048Repository; 275 const denied = await api.createPublicDraftController(repository, { 276 body: 'private', 277 subject: 'private' 278 }); 279 const controller = await api.createPublicDraftController(repository, form); 280 const captured = api.capturePublicDraftCreate(repository, form); 281 if (!controller || !captured.ok) throw new Error('missing genuine handles'); 282 api.closeBrowserDatabase(window.hcp048Database); 283 const commit = await api.commitPublicDraftWrite(repository, captured.value); 284 const flush = await api.flushPublicDraft(controller); 285 const snapshot = api.publicDraftControllerSnapshot(controller); 286 return { denied: denied === undefined, commit, flush, snapshot }; 287 }, form); 288 expect(result.denied).toBe(true); 289 expect(result.commit).toEqual({ ok: false, reason: 'invalid_scope' }); 290 expect(result.flush).toBe(false); 291 expect(result.snapshot).toMatchObject({ 292 state: 'failed', 293 failure: 'invalid_scope', 294 draft: null 295 }); 296 }); 297 298 test('real repository clock reentry cannot acknowledge an older payload as the latest input', async ({ 299 page 300 }) => { 301 await load(page); 302 const result = await page.evaluate(async (form) => { 303 const api = window.hcp048, 304 repository = window.hcp048Repository; 305 const controller = await api.createPublicDraftController(repository, form); 306 if (!controller) throw new Error('missing controller'); 307 const original = Date.now; 308 let calls = 0; 309 Date.now = () => { 310 calls++; 311 if (calls === 1) 312 api.editPublicDraft(controller, { 313 ...form, 314 title: 'clock reentrant latest' 315 }); 316 return original(); 317 }; 318 try { 319 api.editPublicDraft(controller, { 320 ...form, 321 title: 'older captured form' 322 }); 323 const flushed = await api.flushPublicDraft(controller); 324 const snapshot = api.publicDraftControllerSnapshot(controller); 325 const rows = await api.listPublicDrafts(repository); 326 return { flushed, snapshot, rows, calls }; 327 } finally { 328 Date.now = original; 329 } 330 }, form); 331 expect(result.flushed).toBe(true); 332 expect(result.calls).toBe(2); 333 expect(result.snapshot).toMatchObject({ 334 state: 'saved', 335 editVersion: 2, 336 savedEditVersion: 2, 337 form: { title: 'clock reentrant latest' }, 338 draft: { revision: 1, form: { title: 'clock reentrant latest' } } 339 }); 340 expect(result.rows).toEqual({ ok: true, value: [result.snapshot?.draft] }); 341 });