app

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

local-data-review.spec.ts (19627B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { svelte } from '@sveltejs/vite-plugin-svelte';
      4 import { fileURLToPath } from 'node:url';
      5 import { createStaticHarness } from '../integration/harness/static.ts';
      6 import type * as Fixture from './harness/local-data-review.ts';
      7 declare global {
      8   interface Window {
      9     hcp125: typeof Fixture;
     10     hcp125Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>;
     11   }
     12 }
     13 
     14 test('HCP125 first-level SSR privacy discloses public encrypted local and remote limits to guests', async ({
     15   page
     16 }) => {
     17   const server = await createStaticHarness();
     18   try {
     19     await page.addInitScript(() => {
     20       Object.defineProperty(window, 'nostr', {
     21         configurable: true,
     22         get() {
     23           throw Error('guest extension effect');
     24         }
     25       });
     26     });
     27     await page.goto(server.url + '/privacy');
     28     await expect(
     29       page.getByRole('heading', { name: 'Privacy', exact: true })
     30     ).toBeVisible();
     31     expect(await page.getByRole('heading').allTextContents()).toEqual(
     32       expect.arrayContaining([
     33         'Public listings',
     34         'Private messages',
     35         'In this browser',
     36         'Removing information'
     37       ])
     38     );
     39     await expect(
     40       page.getByText('Unsent message text is not automatically saved.', {
     41         exact: false
     42       })
     43     ).toBeVisible();
     44     await expect(
     45       page.getByText('does not remove other people', { exact: false })
     46     ).toBeVisible();
     47     await expect(
     48       page.getByRole('button', {
     49         name: 'Review data in this browser',
     50         exact: true
     51       })
     52     ).toBeVisible();
     53     await page
     54       .getByRole('button', { name: 'Review data in this browser', exact: true })
     55       .click();
     56     await expect(page.locator('[data-local-data-owner]')).toHaveCount(0);
     57     await expect(
     58       page.getByRole('button', { name: 'Confirm removal', exact: true })
     59     ).toHaveCount(0);
     60     await expect(
     61       page.getByRole('button', { name: /clear everything/i })
     62     ).toHaveCount(0);
     63   } finally {
     64     await server.close();
     65   }
     66 });
     67 
     68 test.describe('HCP125 original local data workflow and native storage', () => {
     69   let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     70   test.beforeAll(async () => {
     71     server = await createStaticHarness();
     72     const entry = fileURLToPath(
     73       new URL('./harness/local-data-review.ts', import.meta.url)
     74     );
     75     const result = await build({
     76       configFile: false,
     77       logLevel: 'silent',
     78       plugins: [svelte()],
     79       build: {
     80         write: false,
     81         minify: false,
     82         rolldownOptions: { input: entry },
     83         lib: { entry, name: 'hcp125', formats: ['iife'] }
     84       }
     85     });
     86     const output = Array.isArray(result) ? result[0] : result;
     87     if (!('output' in output)) throw Error('actual fixture output missing');
     88     const chunks = output.output.filter((item) => item.type === 'chunk');
     89     expect(chunks).toHaveLength(1);
     90     bundle = chunks[0].code;
     91   });
     92   test.afterAll(async () => server?.close());
     93   async function load(page: Page, mode = 'normal') {
     94     await page.goto(server.url + '/about');
     95     await page.addScriptTag({ content: bundle });
     96     await page.evaluate(async (mode) => {
     97       window.hcp125Fixture = await window.hcp125.createFixture(mode);
     98     }, mode);
     99   }
    100   test.afterEach(async ({ page }) => {
    101     if (!page.isClosed())
    102       await page.evaluate(async () => window.hcp125Fixture?.close());
    103   });
    104   test('explicit review is owner scoped, starts with no selection, shows protected work and does not leak draft bodies', async ({
    105     page
    106   }) => {
    107     await load(page);
    108     expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({
    109       reads: 0,
    110       signs: 0,
    111       encrypts: 0,
    112       decrypts: 0
    113     });
    114     await page
    115       .getByRole('button', { name: 'Review data in this browser', exact: true })
    116       .click();
    117     await expect(page.locator('[data-local-data-owner]')).toHaveText(
    118       await page.evaluate(() => window.hcp125Fixture.owner)
    119     );
    120     await expect(
    121       page.getByText('Pending or uncertain work is protected.', {
    122         exact: false
    123       })
    124     ).toBeVisible();
    125     await expect(page.locator('#hcp125-panel input:checked')).toHaveCount(0);
    126     await expect(page.locator('#hcp125-panel')).not.toContainText(
    127       'PRIVATE OWNER B SENTINEL'
    128     );
    129     await expect(page.locator('#hcp125-panel')).not.toContainText(
    130       'PUBLIC DRAFT BODY SENTINEL'
    131     );
    132     expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({
    133       reads: 0,
    134       signs: 0,
    135       encrypts: 0,
    136       decrypts: 0
    137     });
    138   });
    139   test('selection preview is reversible; confirmation removes only the selected public draft', async ({
    140     page
    141   }) => {
    142     await load(page);
    143     await page
    144       .getByRole('button', { name: 'Review data in this browser', exact: true })
    145       .click();
    146     await page
    147       .getByRole('checkbox', { name: /Listing draft/ })
    148       .first()
    149       .check();
    150     await page
    151       .getByRole('button', { name: 'Review public removal', exact: true })
    152       .click();
    153     await expect(
    154       page.getByText('does not delete remote copies', { exact: false })
    155     ).toBeVisible();
    156     await page.getByRole('button', { name: 'Keep data', exact: true }).click();
    157     expect(
    158       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    159     ).toBe(2);
    160     await page
    161       .getByRole('checkbox', { name: /Listing draft/ })
    162       .first()
    163       .check();
    164     await page
    165       .getByRole('button', { name: 'Review public removal', exact: true })
    166       .click();
    167     await page
    168       .getByRole('button', { name: 'Confirm removal', exact: true })
    169       .click();
    170     await expect(page.getByRole('status').last()).toContainText(
    171       'Removed 1 selected public record'
    172     );
    173     const rows = await page.evaluate(() => window.hcp125Fixture.rows());
    174     expect(rows.publicDrafts).toBe(1);
    175     expect(rows.foreignDrafts).toBe(1);
    176     expect(rows.publicOperations).toBe(1);
    177   });
    178   test('changed inventory refuses selected removal without resetting local data', async ({
    179     page
    180   }) => {
    181     await load(page);
    182     await page.evaluate(() => window.hcp125Fixture.reviewAndPreview());
    183     await page.evaluate(() => window.hcp125Fixture.changeDraft());
    184     expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe(
    185       false
    186     );
    187     expect(
    188       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    189     ).toBe(2);
    190     expect(
    191       await page.evaluate(() => window.hcp125Fixture.snapshot())
    192     ).toMatchObject({ notice: expect.stringContaining('not confirmed') });
    193   });
    194   test('logout retires inventory and preview and prevents any subsequent deletion', async ({
    195     page
    196   }) => {
    197     await load(page);
    198     await page.evaluate(() => window.hcp125Fixture.reviewAndPreview());
    199     await page.evaluate(() => window.hcp125Fixture.logout());
    200     expect(await page.evaluate(() => window.hcp125Fixture.snapshot())).toEqual({
    201       state: 'guest'
    202     });
    203     expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe(
    204       false
    205     );
    206     expect(
    207       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    208     ).toBe(2);
    209     await expect(page.locator('[data-local-data-owner]')).toHaveCount(0);
    210   });
    211   test('owner invalidation after a real delete request aborts the native transaction and preserves the row', async ({
    212     page
    213   }) => {
    214     await load(page);
    215     await page.evaluate(() => window.hcp125Fixture.reviewAndPreview());
    216     expect(
    217       await page.evaluate(() => window.hcp125Fixture.abortDuringDelete())
    218     ).toMatchObject({
    219       confirmed: false,
    220       deleteSuccesses: 1,
    221       nativeAborts: 1,
    222       nativeTerminal: 'abort'
    223     });
    224     expect(
    225       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    226     ).toBe(2);
    227   });
    228   test('busy real owner Web Lock refuses removal without queueing or deleting', async ({
    229     page
    230   }) => {
    231     await load(page);
    232     await page.evaluate(() => window.hcp125Fixture.reviewAndPreview());
    233     expect(
    234       await page.evaluate(() => window.hcp125Fixture.confirmWhileLocked())
    235     ).toBe(false);
    236     expect(
    237       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    238     ).toBe(2);
    239   });
    240   test('corrupt records refuse inventory without reset and preserve the raw sentinel', async ({
    241     page
    242   }) => {
    243     await load(page, 'corrupt');
    244     await page
    245       .getByRole('button', { name: 'Review data in this browser', exact: true })
    246       .click();
    247     await expect(page.getByRole('status').last()).toContainText(
    248       'Existing local data has not been reset'
    249     );
    250     expect(await page.evaluate(() => window.hcp125Fixture.rawCorrupt())).toBe(
    251       '{"schema":99}'
    252     );
    253     await expect(
    254       page.getByRole('button', { name: 'Confirm removal', exact: true })
    255     ).toHaveCount(0);
    256   });
    257   test('disposal retires original selection and rejects confirmation', async ({
    258     page
    259   }) => {
    260     await load(page);
    261     await page.evaluate(() => window.hcp125Fixture.reviewAndPreview());
    262     await page.evaluate(() => window.hcp125Fixture.dispose());
    263     expect(await page.evaluate(() => window.hcp125Fixture.snapshot())).toEqual({
    264       state: 'closed'
    265     });
    266     expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe(
    267       false
    268     );
    269     expect(
    270       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    271     ).toBe(2);
    272   });
    273   test('malformed duplicate protected or cross-account selections cannot mint a cleanup preview', async ({
    274     page
    275   }) => {
    276     await load(page);
    277     await page.evaluate(() => window.hcp125Fixture.review());
    278     expect(
    279       await page.evaluate(() => window.hcp125Fixture.hostileSelections())
    280     ).toEqual([false, false, false, false, false]);
    281     expect(
    282       (await page.evaluate(() => window.hcp125Fixture.rows())).publicDrafts
    283     ).toBe(2);
    284   });
    285   test('selected received encrypted copy removal preserves outbox other copies and other accounts without decrypting', async ({
    286     page
    287   }) => {
    288     await load(page, 'messaging');
    289     await page
    290       .getByRole('button', { name: 'Review data in this browser', exact: true })
    291       .click();
    292     await page
    293       .getByRole('checkbox', { name: /Encrypted received copy/ })
    294       .first()
    295       .check();
    296     await page
    297       .getByRole('button', { name: 'Review received removal', exact: true })
    298       .click();
    299     await expect(
    300       page.getByText('Relay recovery is not guaranteed.', { exact: false })
    301     ).toBeVisible();
    302     await page
    303       .getByRole('button', { name: 'Confirm removal', exact: true })
    304       .click();
    305     await expect(page.getByRole('status').last()).toContainText(
    306       'Removed 1 selected received encrypted copy'
    307     );
    308     expect(
    309       await page.evaluate(() => window.hcp125Fixture.rows())
    310     ).toMatchObject({
    311       received: 1,
    312       foreignReceived: 1,
    313       outbox: 1,
    314       publicDrafts: 2
    315     });
    316     expect(
    317       await page.evaluate(() => window.hcp125Fixture.effects())
    318     ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 });
    319   });
    320   test('signing-only metadata review does not probe messaging or enable received removal', async ({
    321     page
    322   }) => {
    323     await load(page);
    324     await page
    325       .getByRole('button', { name: 'Review data in this browser', exact: true })
    326       .click();
    327     await expect(
    328       page.getByText(
    329         'Enable messaging explicitly before reviewing received-copy removal.',
    330         { exact: false }
    331       )
    332     ).toBeVisible();
    333     await expect(
    334       page.getByRole('checkbox', { name: /Encrypted received copy/ }).first()
    335     ).toBeDisabled();
    336     expect(await page.evaluate(() => window.hcp125Fixture.effects())).toEqual({
    337       reads: 0,
    338       signs: 0,
    339       encrypts: 0,
    340       decrypts: 0
    341     });
    342   });
    343   test('stale selected received full wire refuses deletion and preserves the changed copy', async ({
    344     page
    345   }) => {
    346     await load(page, 'messaging');
    347     await page.evaluate(() => window.hcp125Fixture.reviewAndPreviewReceived());
    348     await page.evaluate(() => window.hcp125Fixture.changeReceived());
    349     expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe(
    350       false
    351     );
    352     expect(
    353       await page.evaluate(() => window.hcp125Fixture.rows())
    354     ).toMatchObject({ received: 2, foreignReceived: 1, outbox: 1 });
    355   });
    356   test('held old confirmation cannot retire a new original-generation received preview after reconnect', async ({
    357     page
    358   }) => {
    359     await load(page, 'messaging');
    360     const result = await page.evaluate(() =>
    361       window.hcp125Fixture.oldConfirmationThenNewPreview()
    362     );
    363     expect(result).toMatchObject({
    364       held: true,
    365       newer: true,
    366       oldConfirmed: false,
    367       newConfirmed: true,
    368       currentPreview: {
    369         state: 'ready',
    370         preview: { category: 'received', selected: 1 }
    371       }
    372     });
    373     expect(
    374       await page.evaluate(() => window.hcp125Fixture.rows())
    375     ).toMatchObject({
    376       received: 0,
    377       foreignReceived: 1,
    378       outbox: 1,
    379       publicDrafts: 2
    380     });
    381   });
    382   for (const width of [320, 1024])
    383     test('local review fits viewport ' + width, async ({ page }) => {
    384       await page.setViewportSize({ width, height: 900 });
    385       await load(page);
    386       await page
    387         .getByRole('button', {
    388           name: 'Review data in this browser',
    389           exact: true
    390         })
    391         .click();
    392       await expect(page.locator('[data-local-data-owner]')).toBeVisible();
    393       expect(
    394         await page.evaluate(
    395           () => document.documentElement.scrollWidth <= window.innerWidth
    396         )
    397       ).toBe(true);
    398     });
    399 
    400   test('CR004 reviewed settled removal frees actual capacity while preserving other namespaces', async ({
    401     page
    402   }) => {
    403     await load(page, 'outbox');
    404     const before = await page.evaluate(() => window.hcp125Fixture.rows());
    405     expect(before).toMatchObject({
    406       outbox: 100,
    407       publicDrafts: 2,
    408       publicOperations: 1,
    409       received: 2,
    410       foreignReceived: 1
    411     });
    412     expect(await page.evaluate(() => window.hcp125Fixture.reserveNext())).toBe(
    413       'capacity'
    414     );
    415     await page
    416       .getByRole('button', { name: 'Review data in this browser', exact: true })
    417       .click();
    418     await expect(
    419       page.getByRole('checkbox', { name: /Eligible settled send/ })
    420     ).toHaveCount(100);
    421     await page
    422       .getByRole('checkbox', { name: /Eligible settled send/ })
    423       .first()
    424       .check();
    425     await page
    426       .getByRole('button', { name: 'Review settled send removal', exact: true })
    427       .click();
    428     await expect(
    429       page.getByText('duplicate-prevention evidence', { exact: false })
    430     ).toBeVisible();
    431     await page
    432       .getByRole('button', { name: 'Confirm removal', exact: true })
    433       .click();
    434     await expect(page.getByRole('status').last()).toContainText(
    435       'Removed 1 selected settled send record'
    436     );
    437     const removed = await page.evaluate(() => window.hcp125Fixture.rows());
    438     expect(removed).toEqual({ ...before, outbox: 99 });
    439     expect(
    440       await page.evaluate(() => window.hcp125Fixture.effects())
    441     ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 });
    442     const fresh = await page.evaluate(() => window.hcp125Fixture.freshSend());
    443     expect(fresh).toMatchObject({
    444       reservation: 'reserved',
    445       self: 'saved',
    446       pair: 'prepared',
    447       paired: true
    448     });
    449     expect(
    450       await page.evaluate(() => window.hcp125Fixture.settledIds())
    451     ).not.toContain(fresh.id);
    452     expect(
    453       await page.evaluate(() => window.hcp125Fixture.effects())
    454     ).toMatchObject({ signs: 2, encrypts: 2 });
    455     expect(await page.evaluate(() => window.hcp125Fixture.rows())).toEqual(
    456       before
    457     );
    458     expect(await page.evaluate(() => window.hcp125Fixture.reserveNext())).toBe(
    459       'capacity'
    460     );
    461   });
    462 
    463   test('CR004 a second same-origin tab holding the actual owner lock prevents cleanup', async ({
    464     page,
    465     context
    466   }) => {
    467     await load(page, 'outbox');
    468     expect(
    469       await page.evaluate(() => window.hcp125Fixture.reviewAndPreviewOutbox())
    470     ).toBe(true);
    471     const owner = await page.evaluate(() => window.hcp125Fixture.owner),
    472       other = await context.newPage();
    473     try {
    474       await other.goto(server.url + '/about');
    475       await other.evaluate(async (owner) => {
    476         const state = window as typeof window & {
    477           cr004Release?: () => void;
    478           cr004Held?: Promise<void>;
    479         };
    480         let entered = () => {};
    481         const ready = new Promise<void>((resolve) => {
    482           entered = resolve;
    483         });
    484         state.cr004Held = navigator.locks.request(
    485           'harvestcircle:owner:' + owner,
    486           async () => {
    487             entered();
    488             await new Promise<void>((resolve) => {
    489               state.cr004Release = resolve;
    490             });
    491           }
    492         );
    493         await ready;
    494       }, owner);
    495       expect(await page.evaluate(() => window.hcp125Fixture.confirm())).toBe(
    496         false
    497       );
    498       expect(
    499         (await page.evaluate(() => window.hcp125Fixture.rows())).outbox
    500       ).toBe(100);
    501       expect(
    502         await page.evaluate(() => window.hcp125Fixture.effects())
    503       ).toMatchObject({ signs: 0, encrypts: 0, decrypts: 0 });
    504     } finally {
    505       if (!other.isClosed()) {
    506         await other.evaluate(async () => {
    507           const state = window as typeof window & {
    508             cr004Release?: () => void;
    509             cr004Held?: Promise<void>;
    510           };
    511           state.cr004Release?.();
    512           await state.cr004Held;
    513         });
    514         await other.close();
    515       }
    516     }
    517   });
    518 
    519   for (const outcome of [
    520     'changed',
    521     'lock_busy',
    522     'sdk_busy',
    523     'key_changed',
    524     'aborted',
    525     'unknown'
    526   ] as const)
    527     test(
    528       'CR004 actual ' +
    529         outcome +
    530         ' cannot certify removal of the reviewed original',
    531       async ({ page }) => {
    532         await load(page, 'outbox');
    533         expect(
    534           await page.evaluate(() =>
    535             window.hcp125Fixture.reviewAndPreviewOutbox()
    536           )
    537         ).toBe(true);
    538         const result = await page.evaluate(async (outcome) => {
    539           const f = window.hcp125Fixture;
    540           if (outcome === 'changed') await f.changeOutbox();
    541           if (outcome === 'key_changed') f.switchKey();
    542           const fault =
    543             outcome === 'aborted' || outcome === 'unknown'
    544               ? await f.abortOutboxDelete(outcome === 'unknown')
    545               : undefined;
    546           const confirmed =
    547             fault?.confirmed ??
    548             (outcome === 'lock_busy'
    549               ? await f.confirmWhileLocked()
    550               : outcome === 'sdk_busy'
    551                 ? await f.confirmWhileSdkBusy()
    552                 : await f.confirm());
    553           return {
    554             confirmed,
    555             fault,
    556             rows: await f.rows(),
    557             effects: f.effects()
    558           };
    559         }, outcome);
    560         expect(result.confirmed).toBe(false);
    561         expect(result.rows.outbox).toBe(outcome === 'unknown' ? 99 : 100);
    562         expect(result.rows).toMatchObject({
    563           publicDrafts: 2,
    564           publicOperations: 1,
    565           received: 2,
    566           foreignReceived: 1
    567         });
    568         expect(result.effects).toMatchObject({
    569           signs: 0,
    570           encrypts: 0,
    571           decrypts: 0
    572         });
    573         if (outcome === 'aborted')
    574           expect(result.fault).toMatchObject({
    575             deletes: 1,
    576             aborts: 1,
    577             nativeTerminal: 'abort'
    578           });
    579         if (outcome === 'unknown')
    580           expect(result.fault).toMatchObject({
    581             aborts: 0,
    582             nativeTerminal: 'complete'
    583           });
    584       }
    585     );
    586 });