app

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

private-preparation.spec.ts (19186B)


      1 import { expect, test, 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 Preparation from './harness/private-preparation.ts';
      6 declare global {
      7   interface Window {
      8     hcp084: typeof Preparation;
      9     hcp084Fixture: Awaited<ReturnType<typeof Preparation.makeFixture>>;
     10   }
     11 }
     12 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     13 test.beforeAll(async () => {
     14   server = await createStaticHarness();
     15   const built = await build({
     16     configFile: false,
     17     logLevel: 'silent',
     18     build: {
     19       write: false,
     20       minify: false,
     21       lib: {
     22         entry: fileURLToPath(
     23           new URL('./harness/private-preparation.ts', import.meta.url)
     24         ),
     25         name: 'hcp084',
     26         formats: ['iife']
     27       }
     28     }
     29   });
     30   const output = Array.isArray(built) ? built[0] : built;
     31   if (!('output' in output)) throw Error('private fixture bundle missing');
     32   const chunks = output.output.filter((entry) => entry.type === 'chunk');
     33   expect(chunks).toHaveLength(1);
     34   bundle = chunks[0].code;
     35 });
     36 test.afterAll(async () => server.close());
     37 test.afterEach(async ({ page }) => {
     38   await page.evaluate(() => window.hcp084Fixture?.close());
     39 });
     40 test('genuine enquiry binding admits only exact canonical captured body and preserves prior acknowledgement on mismatch', async ({
     41   page
     42 }) => {
     43   await load(page);
     44   const result = await page.evaluate(async () => {
     45     const f = window.hcp084Fixture,
     46       s = window.hcp084,
     47       context = await f.enquiryContext(),
     48       different = await f.enquiryContext('Different carrots');
     49     s.updatePrivateComposerText(f.composer, f.marker, 'reviewed_private_text');
     50     const bound = s.bindPrivateComposerPreparation(
     51       f.composer,
     52       f.reserved,
     53       f.preparation,
     54       context,
     55       'reviewed_composer_preparation'
     56     );
     57     await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
     58     const saved = s.privateComposerSnapshot(f.composer),
     59       bytes = await f.stored(),
     60       wrongContext = s.bindPrivateComposerPreparation(
     61         f.composer,
     62         f.reserved,
     63         f.preparation,
     64         different,
     65         'reviewed_composer_preparation'
     66       ),
     67       afterContext = s.privateComposerSnapshot(f.composer);
     68     s.updatePrivateComposerText(
     69       f.composer,
     70       'different private body',
     71       'reviewed_private_text'
     72     );
     73     const wrongBody = s.bindPrivateComposerPreparation(
     74       f.composer,
     75       f.reserved,
     76       f.preparation,
     77       context,
     78       'reviewed_composer_preparation'
     79     );
     80     return {
     81       bound,
     82       saved: saved?.state,
     83       wrongContext,
     84       unchangedAck: afterContext?.state === saved?.state,
     85       wrongBody,
     86       dirty: s.privateComposerSnapshot(f.composer)?.dirty,
     87       text: s.privateComposerText(f.composer),
     88       bytes: bytes === (await f.stored())
     89     };
     90   });
     91   expect(result).toEqual({
     92     bound: true,
     93     saved: 'saved_encrypted',
     94     wrongContext: false,
     95     unchangedAck: true,
     96     wrongBody: false,
     97     dirty: true,
     98     text: 'different private body',
     99     bytes: true
    100   });
    101 });
    102 async function load(page: Page) {
    103   await page.goto(server.url + '/search');
    104   await page.addScriptTag({ content: bundle });
    105   await page.evaluate(async () => {
    106     window.hcp084Fixture = await window.hcp084.makeFixture();
    107   });
    108 }
    109 test('same-page confirmation defaults Keep editing and Escape preserves exact text and privacy', async ({
    110   page
    111 }) => {
    112   const logs: string[] = [];
    113   page.on('console', (entry) => logs.push(entry.text()));
    114   await load(page);
    115   const original = await page.evaluate(() => {
    116     const f = window.hcp084Fixture;
    117     return {
    118       text: f.original,
    119       result: f.requestClose(),
    120       snapshot: window.hcp084.privateComposerSnapshot(f.composer)
    121     };
    122   });
    123   expect(original.result).toBe('confirmation_required');
    124   expect(original.snapshot?.dirty).toBe(true);
    125   await expect(
    126     page.getByRole('button', { name: 'Keep editing', exact: true })
    127   ).toBeFocused();
    128   await page.getByRole('button', { name: 'Keep editing', exact: true }).click();
    129   await expect(
    130     page.getByRole('textbox', { name: 'Private text', exact: true })
    131   ).toHaveValue(original.text);
    132   await page.evaluate(() => window.hcp084Fixture.requestClose());
    133   await page.keyboard.press('Escape');
    134   await expect(
    135     page.getByRole('textbox', { name: 'Private text', exact: true })
    136   ).toHaveValue(original.text);
    137   const privacy = await page.evaluate(async () => {
    138     const f = window.hcp084Fixture;
    139     return {
    140       public: (await f.publicDraftRows()).includes(f.marker),
    141       private: (await f.stored()).includes(f.marker),
    142       storage: JSON.stringify(localStorage).includes(f.marker),
    143       url: location.href.includes(f.marker),
    144       snapshot: JSON.stringify(
    145         window.hcp084.privateComposerSnapshot(f.composer)
    146       ).includes(f.marker)
    147     };
    148   });
    149   expect(privacy).toEqual({
    150     public: false,
    151     private: false,
    152     storage: false,
    153     url: false,
    154     snapshot: false
    155   });
    156   expect(
    157     logs.some((line) =>
    158       line.includes('HCP081_PRIVATE_TEXT_MEMORY_ONLY_SENTINEL')
    159     )
    160   ).toBe(false);
    161 });
    162 test('stale discard cannot clear new edits; reviewed same-revision discard is one-shot', async ({
    163   page
    164 }) => {
    165   await load(page);
    166   const result = await page.evaluate(() => {
    167     const f = window.hcp084Fixture,
    168       s = window.hcp084;
    169     f.requestClose();
    170     s.updatePrivateComposerText(
    171       f.composer,
    172       'newer private value',
    173       'reviewed_private_text'
    174     );
    175     const stale = s.confirmDiscardNavigation(
    176         f.navigation,
    177         'reviewed_discard_private_text'
    178       ),
    179       kept = s.privateComposerText(f.composer);
    180     f.requestClose();
    181     const denied = s.confirmDiscardNavigation(f.navigation, 'unreviewed'),
    182       accepted = s.confirmDiscardNavigation(
    183         f.navigation,
    184         'reviewed_discard_private_text'
    185       );
    186     return {
    187       stale,
    188       kept,
    189       denied,
    190       accepted,
    191       text: s.privateComposerText(f.composer),
    192       repeated: s.confirmDiscardNavigation(
    193         f.navigation,
    194         'reviewed_discard_private_text'
    195       )
    196     };
    197   });
    198   expect(result).toEqual({
    199     stale: 'review_required',
    200     kept: 'newer private value',
    201     denied: 'invalid',
    202     accepted: 'allowed',
    203     text: '',
    204     repeated: 'invalid'
    205   });
    206 });
    207 test('beforeunload warns only while exact private text lacks encrypted acknowledgement', async ({
    208   page
    209 }) => {
    210   await load(page);
    211   const result = await page.evaluate(async () => {
    212     const f = window.hcp084Fixture,
    213       s = window.hcp084,
    214       detach = s.attachPrivateBeforeUnload(f.navigation);
    215     const first = new Event('beforeunload', { cancelable: true });
    216     window.dispatchEvent(first);
    217     await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    218     const saved = s.privateComposerSnapshot(f.composer),
    219       second = new Event('beforeunload', { cancelable: true });
    220     window.dispatchEvent(second);
    221     detach?.();
    222     return {
    223       dirtyPrevented: first.defaultPrevented,
    224       savedPrevented: second.defaultPrevented,
    225       saved: saved?.state,
    226       dirty: saved?.dirty
    227     };
    228   });
    229   expect(result).toEqual({
    230     dirtyPrevented: true,
    231     savedPrevented: false,
    232     saved: 'saved_encrypted',
    233     dirty: false
    234   });
    235 });
    236 test('acknowledged ciphertext labels only captured text revision; newer value stays unsaved', async ({
    237   page
    238 }) => {
    239   await load(page);
    240   const result = await page.evaluate(async () => {
    241     const f = window.hcp084Fixture,
    242       s = window.hcp084;
    243     await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    244     const saved = s.privateComposerSnapshot(f.composer),
    245       bytes = await f.stored();
    246     s.updatePrivateComposerText(
    247       f.composer,
    248       'edited after capture',
    249       'reviewed_private_text'
    250     );
    251     const changed = s.privateComposerSnapshot(f.composer);
    252     return {
    253       saved: saved?.state,
    254       changed: changed?.state,
    255       dirty: changed?.dirty,
    256       value: s.privateComposerText(f.composer),
    257       unchanged: bytes === (await f.stored()),
    258       plaintext: (await f.stored()).includes('edited after capture')
    259     };
    260   });
    261   expect(result).toEqual({
    262     saved: 'saved_encrypted',
    263     changed: 'unsaved',
    264     dirty: true,
    265     value: 'edited after capture',
    266     unchanged: true,
    267     plaintext: false
    268   });
    269 });
    270 for (const mode of ['declined', 'missing', 'changed_key'] as const)
    271   test(
    272     mode + ' self preparation never labels dirty text saved',
    273     async ({ page }) => {
    274       await load(page);
    275       const result = await page.evaluate(async (mode) => {
    276         const f = window.hcp084Fixture,
    277           s = window.hcp084;
    278         f.mode(mode);
    279         await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    280         const state = s.privateComposerSnapshot(f.composer);
    281         return {
    282           saved: state?.state === 'saved_encrypted',
    283           dirty: state?.dirty ?? true,
    284           receipt: !!s.preparedSelfRecovery(f.preparation),
    285           plaintext: (await f.stored()).includes(f.marker)
    286         };
    287       }, mode);
    288       expect(result).toEqual({
    289         saved: false,
    290         dirty: true,
    291         receipt: false,
    292         plaintext: false
    293       });
    294     }
    295   );
    296 for (const mode of ['abort', 'unknown'] as const)
    297   test(
    298     mode + ' actual self transaction cannot turn draft into a fresh send',
    299     async ({ page }) => {
    300       await load(page);
    301       const result = await page.evaluate(async (mode) => {
    302         const f = window.hcp084Fixture,
    303           s = window.hcp084,
    304           hits = f.fault(mode);
    305         const outcome = await s.prepareSelfRecovery(
    306             f.preparation,
    307             'reviewed_self_recovery'
    308           ),
    309           state = s.privateComposerSnapshot(f.composer);
    310         return {
    311           outcome: outcome.status,
    312           hits: hits(),
    313           state: state?.state,
    314           dirty: state?.dirty,
    315           plaintext: (await f.stored()).includes(f.marker),
    316           value: s.privateComposerText(f.composer) === f.original
    317         };
    318       }, mode);
    319       expect(result).toEqual(
    320         mode === 'abort'
    321           ? {
    322               outcome: 'aborted',
    323               hits: 1,
    324               state: 'needs_action',
    325               dirty: true,
    326               plaintext: false,
    327               value: true
    328             }
    329           : {
    330               outcome: 'reconciled',
    331               hits: 1,
    332               state: 'saved_encrypted',
    333               dirty: false,
    334               plaintext: false,
    335               value: true
    336             }
    337       );
    338     }
    339   );
    340 for (const action of ['discard', 'disconnect'] as const)
    341   test(
    342     action +
    343       ' during real SDK wait preserves pending owner occupancy and cannot advance effects',
    344     async ({ page }) => {
    345       await load(page);
    346       await page.evaluate(() => {
    347         const f = window.hcp084Fixture;
    348         f.mode('hold_encrypt');
    349         Reflect.set(
    350           window,
    351           'hcp084Pending',
    352           window.hcp084.prepareSelfRecovery(
    353             f.preparation,
    354             'reviewed_self_recovery'
    355           )
    356         );
    357       });
    358       await expect
    359         .poll(() =>
    360           page.evaluate(() => window.hcp084Fixture.pendingEncryption())
    361         )
    362         .toBe(true);
    363       const waiting = await page.evaluate((action) => {
    364         const f = window.hcp084Fixture,
    365           s = window.hcp084;
    366         if (action === 'discard') {
    367           f.requestClose();
    368           s.confirmDiscardNavigation(
    369             f.navigation,
    370             'reviewed_discard_private_text'
    371           );
    372         } else s.disconnectIdentity(f.identity);
    373         return {
    374           pending: f.pendingEncryption(),
    375           receipt: !!s.preparedSelfRecovery(f.preparation),
    376           text: s.privateComposerText(f.composer) ?? '',
    377           bytes: f.counts().encrypts
    378         };
    379       }, action);
    380       expect(waiting.pending).toBe(true);
    381       expect(waiting.receipt).toBe(false);
    382       expect(waiting.text).toBe('');
    383       const settled = await page.evaluate(async () => {
    384         const f = window.hcp084Fixture;
    385         f.settle();
    386         const result = (await Reflect.get(window, 'hcp084Pending')) as {
    387           status: string;
    388         };
    389         return {
    390           status: result.status,
    391           pending: f.pendingEncryption(),
    392           receipt: !!window.hcp084.preparedSelfRecovery(f.preparation),
    393           plaintext: (await f.stored()).includes(f.marker)
    394         };
    395       });
    396       expect(settled).toEqual({
    397         status: 'stopped',
    398         pending: false,
    399         receipt: false,
    400         plaintext: false
    401       });
    402     }
    403   );
    404 for (const mode of ['abort', 'unknown'] as const)
    405   test(
    406     mode +
    407       ' pair transaction retains only genuine local self fact and no remote effect',
    408     async ({ page }) => {
    409       let sockets = 0;
    410       page.on('websocket', () => sockets++);
    411       await load(page);
    412       const result = await page.evaluate(async (mode) => {
    413         const f = window.hcp084Fixture,
    414           s = window.hcp084;
    415         await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    416         const old = await f.stored(),
    417           hits = f.fault(mode),
    418           result = await s.preparePairedDelivery(
    419             f.preparation,
    420             f.context,
    421             'reviewed_pair_preparation'
    422           ),
    423           snapshot = s.privateComposerSnapshot(f.composer);
    424         return {
    425           status: result.status,
    426           hits: hits(),
    427           state: snapshot?.state,
    428           pair: snapshot?.pairState,
    429           dirty: snapshot?.dirty,
    430           unchanged: old === (await f.stored()),
    431           plaintext: (await f.stored()).includes(f.marker)
    432         };
    433       }, mode);
    434       expect(result).toEqual(
    435         mode === 'abort'
    436           ? {
    437               status: 'aborted',
    438               hits: 1,
    439               state: 'saved_encrypted',
    440               pair: 'needs_action',
    441               dirty: false,
    442               unchanged: true,
    443               plaintext: false
    444             }
    445           : {
    446               status: 'reconciled',
    447               hits: 1,
    448               state: 'saved_encrypted',
    449               pair: 'prepared',
    450               dirty: false,
    451               unchanged: false,
    452               plaintext: false
    453             }
    454       );
    455       expect(sockets).toBe(0);
    456     }
    457   );
    458 test('body budget and unreviewed edits preserve prior exact memory value', async ({
    459   page
    460 }) => {
    461   await load(page);
    462   const result = await page.evaluate(() => {
    463     const f = window.hcp084Fixture,
    464       s = window.hcp084;
    465     return {
    466       oversized: s.updatePrivateComposerText(
    467         f.composer,
    468         'x'.repeat(4097),
    469         'reviewed_private_text'
    470       ),
    471       unreviewed: s.updatePrivateComposerText(
    472         f.composer,
    473         'replacement',
    474         'unreviewed'
    475       ),
    476       equal: s.privateComposerText(f.composer) === f.original
    477     };
    478   });
    479   expect(result).toEqual({ oversized: false, unreviewed: false, equal: true });
    480 });
    481 
    482 for (const role of ['self', 'pair'] as const)
    483   test(
    484     role +
    485       ' actual committed write with unavailable readback remains uncertain instead of fresh',
    486     async ({ page }) => {
    487       await load(page);
    488       const result = await page.evaluate(async (role) => {
    489         const f = window.hcp084Fixture,
    490           s = window.hcp084;
    491         if (role === 'pair')
    492           await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    493         const restore = f.loseReadback();
    494         const outcome =
    495           role === 'self'
    496             ? await s.prepareSelfRecovery(
    497                 f.preparation,
    498                 'reviewed_self_recovery'
    499               )
    500             : await s.preparePairedDelivery(
    501                 f.preparation,
    502                 f.context,
    503                 'reviewed_pair_preparation'
    504               );
    505         const state = s.privateComposerSnapshot(f.composer),
    506           rebinding = s.bindPrivateComposerPreparation(
    507             f.composer,
    508             f.reserved,
    509             f.preparation,
    510             undefined,
    511             'reviewed_composer_preparation'
    512           );
    513         restore();
    514         s.stopSelfRecoveryPreparation(f.preparation);
    515         const fresh = s.captureSelfRecoveryPreparation(
    516           f.repository,
    517           f.identity,
    518           f.reserved,
    519           'reviewed_self_recovery'
    520         );
    521         if (!fresh) throw Error('fresh genuine controller missing');
    522         const freshBinding = s.bindPrivateComposerPreparation(
    523             f.composer,
    524             f.reserved,
    525             fresh,
    526             undefined,
    527             'reviewed_composer_preparation'
    528           ),
    529           retired = s.privateComposerSnapshot(f.composer);
    530         s.stopSelfRecoveryPreparation(fresh);
    531         return {
    532           outcome: outcome.status,
    533           readbackFailures: f.readbackFailures(),
    534           state: state?.state,
    535           pair: state?.pairState,
    536           dirty: state?.dirty,
    537           rebinding,
    538           freshBinding,
    539           uncertaintyRetained:
    540             retired?.state === state?.state &&
    541             retired?.pairState === state?.pairState,
    542           original: s.privateComposerText(f.composer) === f.original,
    543           ciphertext: !!(await f.storedPair()),
    544           plaintext: (await f.stored()).includes(f.marker)
    545         };
    546       }, role);
    547       expect(result).toEqual(
    548         role === 'self'
    549           ? {
    550               outcome: 'unknown_completion',
    551               readbackFailures: 1,
    552               state: 'unknown_completion',
    553               pair: 'unprepared',
    554               dirty: true,
    555               rebinding: false,
    556               freshBinding: false,
    557               uncertaintyRetained: true,
    558               original: true,
    559               ciphertext: true,
    560               plaintext: false
    561             }
    562           : {
    563               outcome: 'unknown_completion',
    564               readbackFailures: 1,
    565               state: 'saved_encrypted',
    566               pair: 'unknown_completion',
    567               dirty: false,
    568               rebinding: false,
    569               freshBinding: false,
    570               uncertaintyRetained: true,
    571               original: true,
    572               ciphertext: true,
    573               plaintext: false
    574             }
    575       );
    576     }
    577   );
    578 
    579 test('pair readback conflict cannot keep a prepared presentation from its prior genuine acknowledgement', async ({
    580   page
    581 }) => {
    582   await load(page);
    583   const result = await page.evaluate(async () => {
    584     const f = window.hcp084Fixture,
    585       s = window.hcp084;
    586     await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    587     await s.preparePairedDelivery(
    588       f.preparation,
    589       f.context,
    590       'reviewed_pair_preparation'
    591     );
    592     const before = s.privateComposerSnapshot(f.composer)?.pairState;
    593     await f.changePairRevision();
    594     const bytes = await f.stored();
    595     const retry = await s.preparePairedDelivery(
    596       f.preparation,
    597       f.context,
    598       'reviewed_pair_preparation'
    599     );
    600     return {
    601       before,
    602       retry: retry.status,
    603       after: s.privateComposerSnapshot(f.composer)?.pairState,
    604       unchanged: bytes === (await f.stored())
    605     };
    606   });
    607   expect(result).toEqual({
    608     before: 'prepared',
    609     retry: 'conflict',
    610     after: 'needs_action',
    611     unchanged: true
    612   });
    613 });