app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 }