idb-open.spec.ts (15396B)
1 import { expect, test, type Page } from '@playwright/test'; 2 import { createHash } from 'node:crypto'; 3 import { readFile } from 'node:fs/promises'; 4 import ts from 'typescript'; 5 import { createStaticHarness } from '../integration/harness/static.ts'; 6 import type * as Database from '../../src/lib/persistence/database.ts'; 7 declare global { 8 interface Window { 9 hcp045: typeof Database; 10 } 11 } 12 let server: Awaited<ReturnType<typeof createStaticHarness>>; 13 let schema: string; 14 let database: string; 15 test.beforeAll(async () => { 16 server = await createStaticHarness(); 17 schema = await readFile( 18 new URL('../../src/lib/persistence/schema.ts', import.meta.url), 19 'utf8' 20 ); 21 database = await readFile( 22 new URL('../../src/lib/persistence/database.ts', import.meta.url), 23 'utf8' 24 ); 25 console.log( 26 JSON.stringify({ 27 fixture: 'HCP045_REAL_CHROMIUM_NATIVE_IDB', 28 schema: createHash('sha256').update(schema).digest('hex'), 29 database: createHash('sha256').update(database).digest('hex'), 30 exposure: 'test-only module URLs; no production route or dependency' 31 }) 32 ); 33 }); 34 test.afterAll(async () => server.close()); 35 function javascript(source: string): string { 36 return ts.transpileModule(source, { 37 compilerOptions: { 38 target: ts.ScriptTarget.ES2022, 39 module: ts.ModuleKind.ESNext 40 } 41 }).outputText; 42 } 43 async function load(page: Page, futureVersionProbe = false) { 44 // Production has no released old schema. A separately labelled version2 45 // variant tests the native blocked-upgrade event, never a supported migration. 46 const selected = futureVersionProbe 47 ? schema.replace( 48 'export const browserSchemaVersion = 1;', 49 'export const browserSchemaVersion = 2;' 50 ) 51 : schema; 52 if (futureVersionProbe) expect(selected).not.toBe(schema); 53 expect(database.split("from './schema.ts'")).toHaveLength(2); 54 await page.route('**/__hcp045/schema.js', (route) => 55 route.fulfill({ 56 contentType: 'text/javascript', 57 body: javascript(selected) 58 }) 59 ); 60 await page.route('**/__hcp045/database.js', (route) => 61 route.fulfill({ 62 contentType: 'text/javascript', 63 body: 64 javascript( 65 database.replace("from './schema.ts'", "from './schema.js'") 66 ) + 67 '\nglobalThis.hcp045={openBrowserDatabase,closeBrowserDatabase,browserDatabaseState,browserDatabaseTransaction};' 68 }) 69 ); 70 await page.goto(server.url + '/search'); 71 await page.addScriptTag({ 72 url: server.url + '/__hcp045/database.js', 73 type: 'module' 74 }); 75 } 76 77 test('fresh schema, acknowledged records, reopen, owner revocation and transaction admission use actual IndexedDB', async ({ 78 page 79 }) => { 80 await load(page); 81 const result = await page.evaluate(async () => { 82 const api = window.hcp045; 83 const opened = await api.openBrowserDatabase(); 84 if (opened.state !== 'ready') throw new Error(opened.reason); 85 const transaction = api.browserDatabaseTransaction( 86 opened.owner, 87 ['public_drafts'], 88 'readwrite' 89 ); 90 // Test-only sentinel, not a qualified public draft record or repository. 91 transaction 92 .objectStore('public_drafts') 93 .put({ owner: 'test-owner', id: 'sentinel', value: 'preserve' }); 94 await new Promise<void>((resolve, reject) => { 95 transaction.addEventListener('complete', () => resolve()); 96 transaction.addEventListener('abort', () => reject(new Error('abort'))); 97 }); 98 let rejected = 0; 99 for (const stores of [ 100 [], 101 ['public_drafts', 'public_drafts'], 102 ['unknown'] 103 ]) { 104 try { 105 api.browserDatabaseTransaction( 106 opened.owner, 107 stores as ['public_drafts'], 108 'readonly' 109 ); 110 } catch { 111 rejected++; 112 } 113 } 114 api.closeBrowserDatabase(opened.owner); 115 api.closeBrowserDatabase(opened.owner); 116 const closed = api.browserDatabaseState(opened.owner); 117 try { 118 api.browserDatabaseTransaction( 119 opened.owner, 120 ['public_drafts'], 121 'readonly' 122 ); 123 } catch { 124 rejected++; 125 } 126 const reopened = await api.openBrowserDatabase(); 127 if (reopened.state !== 'ready') throw new Error(reopened.reason); 128 const read = api 129 .browserDatabaseTransaction(reopened.owner, ['public_drafts'], 'readonly') 130 .objectStore('public_drafts') 131 .get(['test-owner', 'sentinel']); 132 const value = await new Promise<unknown>((resolve, reject) => { 133 read.addEventListener('success', () => resolve(read.result)); 134 read.addEventListener('error', () => reject(new Error('read_failed'))); 135 }); 136 api.closeBrowserDatabase(reopened.owner); 137 return { closed, rejected, value }; 138 }); 139 expect(result).toEqual({ 140 closed: { state: 'closed', reason: 'explicit' }, 141 rejected: 4, 142 value: { owner: 'test-owner', id: 'sentinel', value: 'preserve' } 143 }); 144 }); 145 146 test('real version change closes the owned connection and rejects the unsupported future schema', async ({ 147 page, 148 context 149 }) => { 150 await load(page); 151 await page.evaluate(async () => { 152 const opened = await window.hcp045.openBrowserDatabase(); 153 if (opened.state !== 'ready') throw new Error(opened.reason); 154 // Retain only a test closure, never an exported raw production connection. 155 Object.assign(window, { 156 readHcp045State: () => window.hcp045.browserDatabaseState(opened.owner) 157 }); 158 }); 159 const other = await context.newPage(); 160 await other.goto(server.url + '/search'); 161 expect( 162 await other.evaluate( 163 () => 164 new Promise<number>((resolve, reject) => { 165 const request = indexedDB.open('harvestcircle_browser', 2); 166 request.addEventListener('success', () => { 167 const version = request.result.version; 168 request.result.close(); 169 resolve(version); 170 }); 171 request.addEventListener('error', () => 172 reject(new Error('upgrade_failed')) 173 ); 174 }) 175 ) 176 ).toBe(2); 177 const state = await page.evaluate(() => { 178 const host = window as unknown as { readHcp045State: () => unknown }; 179 return host.readHcp045State(); 180 }); 181 expect(state).toEqual({ state: 'closed', reason: 'version_change' }); 182 expect( 183 await page.evaluate(() => window.hcp045.openBrowserDatabase()) 184 ).toMatchObject({ state: 'unavailable', reason: 'incompatible_version' }); 185 }); 186 187 test('actual other-tab blocked upgrade fails closed; late release cannot expose or migrate an abandoned owner', async ({ 188 page, 189 context 190 }) => { 191 const incumbent = await context.newPage(); 192 await incumbent.goto(server.url + '/search'); 193 await incumbent.evaluate( 194 () => 195 new Promise<void>((resolve, reject) => { 196 const request = indexedDB.open('harvestcircle_browser', 1); 197 request.addEventListener('success', () => { 198 Object.assign(window, { 199 closeIncumbent: () => request.result.close() 200 }); 201 resolve(); 202 }); 203 request.addEventListener('error', () => 204 reject(new Error('incumbent_failed')) 205 ); 206 }) 207 ); 208 await load(page, true); 209 const blocked = await page.evaluate(() => 210 window.hcp045.openBrowserDatabase() 211 ); 212 expect(blocked).toMatchObject({ state: 'unavailable', reason: 'blocked' }); 213 await incumbent.evaluate(() => { 214 (window as unknown as { closeIncumbent: () => void }).closeIncumbent(); 215 }); 216 // A following request serializes behind the abandoned real upgrade. Its v1 217 // success proves that the late upgrade aborted and no hidden v2 reset won. 218 expect( 219 await incumbent.evaluate( 220 () => 221 new Promise<number>((resolve, reject) => { 222 const request = indexedDB.open('harvestcircle_browser', 1); 223 request.addEventListener('success', () => { 224 const version = request.result.version; 225 request.result.close(); 226 resolve(version); 227 }); 228 request.addEventListener('error', () => 229 reject(new Error('late_upgrade_mutated_state')) 230 ); 231 }) 232 ) 233 ).toBe(1); 234 }); 235 236 test('actual migration transaction abort is reported; only an explicit new attempt initializes', async ({ 237 page 238 }) => { 239 await load(page); 240 const result = await page.evaluate(async () => { 241 const original = Object.getOwnPropertyDescriptor( 242 IDBDatabase.prototype, 243 'createObjectStore' 244 ); 245 if (!original) throw new Error('missing_browser_prototype'); 246 IDBDatabase.prototype.createObjectStore = function () { 247 throw new DOMException('test-only failure', 'QuotaExceededError'); 248 }; 249 let failed; 250 try { 251 failed = await window.hcp045.openBrowserDatabase(); 252 } finally { 253 Object.defineProperty( 254 IDBDatabase.prototype, 255 'createObjectStore', 256 original 257 ); 258 } 259 const retry = await window.hcp045.openBrowserDatabase(); 260 if (retry.state === 'ready') 261 window.hcp045.closeBrowserDatabase(retry.owner); 262 return { failed, retry: retry.state }; 263 }); 264 expect(result.failed).toMatchObject({ 265 state: 'unavailable', 266 reason: 'migration_failed' 267 }); 268 expect(result.retry).toBe('ready'); 269 }); 270 271 test('corrupt existing schema and sentinel data are preserved without reset', async ({ 272 page 273 }) => { 274 await load(page); 275 const result = await page.evaluate(async () => { 276 await new Promise<void>((resolve, reject) => { 277 const request = indexedDB.open('harvestcircle_browser', 1); 278 request.addEventListener('upgradeneeded', () => 279 request.result 280 .createObjectStore('unknown_records') 281 .put('retain', 'sentinel') 282 ); 283 request.addEventListener('success', () => { 284 request.result.close(); 285 resolve(); 286 }); 287 request.addEventListener('error', () => 288 reject(new Error('fixture_failed')) 289 ); 290 }); 291 const failed = await window.hcp045.openBrowserDatabase(); 292 const sentinel = await new Promise<unknown>((resolve, reject) => { 293 const request = indexedDB.open('harvestcircle_browser', 1); 294 request.addEventListener('success', () => { 295 const read = request.result 296 .transaction('unknown_records') 297 .objectStore('unknown_records') 298 .get('sentinel'); 299 read.addEventListener('success', () => { 300 request.result.close(); 301 resolve(read.result); 302 }); 303 read.addEventListener('error', () => 304 reject(new Error('sentinel_failed')) 305 ); 306 }); 307 request.addEventListener('error', () => 308 reject(new Error('fixture_reopen_failed')) 309 ); 310 }); 311 return { failed, sentinel }; 312 }); 313 expect(result.failed).toMatchObject({ 314 state: 'unavailable', 315 reason: 'corrupt_schema' 316 }); 317 expect(result.sentinel).toBe('retain'); 318 }); 319 320 test('denied capability branch returns browse-only explanation and keeps the real public page usable', async ({ 321 page 322 }) => { 323 await load(page); 324 const failed = await page.evaluate(async () => { 325 // Browser capability denial branch injection, not private-mode qualification. 326 const original = Object.getOwnPropertyDescriptor(window, 'indexedDB'); 327 Object.defineProperty(window, 'indexedDB', { 328 configurable: true, 329 get() { 330 throw new DOMException('test-only denied', 'SecurityError'); 331 } 332 }); 333 try { 334 return await window.hcp045.openBrowserDatabase(); 335 } finally { 336 if (original) Object.defineProperty(window, 'indexedDB', original); 337 else Reflect.deleteProperty(window, 'indexedDB'); 338 } 339 }); 340 expect(failed).toMatchObject({ 341 state: 'unavailable', 342 reason: 'denied', 343 message: expect.stringContaining('still browse') 344 }); 345 await expect( 346 page.getByRole('textbox', { name: 'What are you looking for?' }) 347 ).toBeVisible(); 348 }); 349 350 test('immediate cancellation owns the pending real open and permits only a separate explicit retry', async ({ 351 page 352 }) => { 353 await load(page); 354 const result = await page.evaluate(async () => { 355 const controller = new AbortController(); 356 const pending = window.hcp045.openBrowserDatabase(controller.signal); 357 controller.abort(); 358 const cancelled = await pending; 359 const retry = await window.hcp045.openBrowserDatabase(); 360 if (retry.state === 'ready') 361 window.hcp045.closeBrowserDatabase(retry.owner); 362 return { cancelled, retry: retry.state }; 363 }); 364 expect(result.cancelled).toMatchObject({ 365 state: 'unavailable', 366 reason: 'cancelled' 367 }); 368 expect(result.retry).toBe('ready'); 369 }); 370 371 for (const defect of [ 372 'key_path', 373 'auto_increment', 374 'unique_index', 375 'missing_index', 376 'extra_index' 377 ] as const) { 378 test(`exact schema rejects ${defect} and preserves existing data`, async ({ 379 page 380 }) => { 381 await load(page); 382 const result = await page.evaluate(async (defect) => { 383 const stores = [ 384 'public_drafts', 385 'public_operations', 386 'preference_operations', 387 'private_sends', 388 'received_envelopes', 389 'conversations', 390 'local_preferences' 391 ]; 392 await new Promise<void>((resolve, reject) => { 393 const request = indexedDB.open('harvestcircle_browser', 1); 394 request.addEventListener('upgradeneeded', () => { 395 for (const name of stores) { 396 const selected = name === 'public_drafts'; 397 const store = request.result.createObjectStore(name, { 398 keyPath: 399 selected && 400 (defect === 'key_path' || defect === 'auto_increment') 401 ? 'id' 402 : ['owner', 'id'], 403 autoIncrement: selected && defect === 'auto_increment' 404 }); 405 if (!(selected && defect === 'missing_index')) 406 store.createIndex('by_owner', 'owner', { 407 unique: selected && defect === 'unique_index' 408 }); 409 if (selected && defect === 'extra_index') 410 store.createIndex('unexpected', 'id'); 411 } 412 request.transaction 413 ?.objectStore('local_preferences') 414 .put({ owner: 'test-owner', id: 'sentinel', value: 'preserve' }); 415 }); 416 request.addEventListener('success', () => { 417 request.result.close(); 418 resolve(); 419 }); 420 request.addEventListener('error', () => 421 reject(new Error('fixture_failed')) 422 ); 423 }); 424 const failed = await window.hcp045.openBrowserDatabase(); 425 const sentinel = await new Promise<unknown>((resolve, reject) => { 426 const request = indexedDB.open('harvestcircle_browser', 1); 427 request.addEventListener('success', () => { 428 const read = request.result 429 .transaction('local_preferences') 430 .objectStore('local_preferences') 431 .get(['test-owner', 'sentinel']); 432 read.addEventListener('success', () => { 433 request.result.close(); 434 resolve(read.result); 435 }); 436 read.addEventListener('error', () => 437 reject(new Error('read_failed')) 438 ); 439 }); 440 request.addEventListener('error', () => 441 reject(new Error('reopen_failed')) 442 ); 443 }); 444 return { failed, sentinel }; 445 }, defect); 446 expect(result.failed).toMatchObject({ 447 state: 'unavailable', 448 reason: 'corrupt_schema' 449 }); 450 expect(result.sentinel).toEqual({ 451 owner: 'test-owner', 452 id: 'sentinel', 453 value: 'preserve' 454 }); 455 }); 456 }