app

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

inbox-view.spec.ts (17665B)


      1 import { test, expect } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { svelte } from '@sveltejs/vite-plugin-svelte';
      4 import { fileURLToPath } from 'node:url';
      5 import { once } from 'node:events';
      6 import { WebSocketServer } from 'ws';
      7 import { createStaticHarness } from '../integration/harness/static.ts';
      8 import type * as Fixture from './harness/inbox-view.ts';
      9 declare global {
     10   interface Window {
     11     hcp101: typeof Fixture;
     12     hcp101Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>;
     13     hcp101SetupFixture: Awaited<ReturnType<typeof Fixture.renderSetupFixture>>;
     14     hcp101Provider?: Awaited<ReturnType<typeof Fixture.makeSetupFixture>>;
     15     hcp101Pending?: Promise<boolean>;
     16   }
     17 }
     18 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     19   sockets: WebSocketServer,
     20   endpoint: string,
     21   bundle: string;
     22 let requests: unknown[][] = [],
     23   closes: unknown[][] = [],
     24   events: unknown[][] = [];
     25 test.beforeAll(async () => {
     26   server = await createStaticHarness();
     27   sockets = new WebSocketServer({
     28     host: '127.0.0.1',
     29     port: 0,
     30     maxPayload: 65536
     31   });
     32   await once(sockets, 'listening');
     33   const address = sockets.address();
     34   if (!address || typeof address === 'string')
     35     throw Error('loopback unavailable');
     36   endpoint = 'ws://127.0.0.1:' + address.port;
     37   sockets.on('connection', (socket) =>
     38     socket.on('message', (bytes) => {
     39       const raw = Buffer.isBuffer(bytes)
     40           ? bytes
     41           : Array.isArray(bytes)
     42             ? Buffer.concat(bytes)
     43             : Buffer.from(bytes),
     44         frame = JSON.parse(raw.toString()) as unknown[];
     45       if (frame[0] === 'CLOSE') closes.push(frame);
     46       if (frame[0] === 'EVENT') events.push(frame);
     47       if (frame[0] === 'REQ') {
     48         requests.push(frame);
     49         socket.send(JSON.stringify(['EOSE', frame[1]]));
     50       }
     51     })
     52   );
     53   const result = await build({
     54     configFile: false,
     55     logLevel: 'silent',
     56     plugins: [svelte({ configFile: false })],
     57     resolve: {
     58       conditions: ['browser'],
     59       alias: {
     60         '$app/navigation': fileURLToPath(
     61           new URL('./harness/inbox-view.ts', import.meta.url)
     62         )
     63       }
     64     },
     65     build: {
     66       write: false,
     67       minify: false,
     68       lib: {
     69         entry: fileURLToPath(
     70           new URL('./harness/inbox-view.ts', import.meta.url)
     71         ),
     72         name: 'hcp101',
     73         formats: ['iife']
     74       }
     75     }
     76   });
     77   const output = Array.isArray(result) ? result[0] : result;
     78   if (!('output' in output)) throw Error('missing bundle');
     79   const chunks = output.output.filter((row) => row.type === 'chunk');
     80   expect(chunks).toHaveLength(1);
     81   bundle = chunks[0].code;
     82 });
     83 test('original setup cleanup survives actual identity invalidation before page closure', async ({
     84   page
     85 }) => {
     86   await page.evaluate(async () => {
     87     window.hcp101Fixture = await window.hcp101.renderFixture(0);
     88   });
     89   const observed = await page.evaluate(() =>
     90     window.hcp101Fixture.closeInvalidatedPage()
     91   );
     92   console.log('actual original setup cleanup', JSON.stringify(observed));
     93   expect(observed.closedSetups).toBe(1);
     94   expect(observed.setupStatus).toBe('closed');
     95   expect(observed.closed).toBe(true);
     96   expect(events).toEqual([]);
     97   expect(requests).toEqual([]);
     98 });
     99 test.afterAll(async () => {
    100   for (const socket of sockets.clients) socket.terminate();
    101   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    102   await server.close();
    103 });
    104 test.beforeEach(async ({ page }) => {
    105   requests = [];
    106   closes = [];
    107   events = [];
    108   await page.addInitScript(
    109     ({ endpoint }) => {
    110       const Native = window.WebSocket;
    111       window.WebSocket = class extends Native {
    112         constructor(url: string | URL, protocols?: string | string[]) {
    113           if (
    114             ![
    115               'wss://archive.example.org',
    116               'wss://discovery.example.org'
    117             ].includes(new URL(String(url)).origin)
    118           )
    119             throw Error('unapproved destination');
    120           super(endpoint, protocols);
    121         }
    122       };
    123     },
    124     { endpoint }
    125   );
    126   await page.goto(server.url + '/search');
    127   await page.addScriptTag({ content: bundle });
    128 });
    129 test.afterEach(async ({ page }) => {
    130   if (!page.isClosed())
    131     await page.evaluate(async () => {
    132       window.hcp101Fixture?.settle();
    133       await window.hcp101Pending;
    134       await window.hcp101Fixture?.close();
    135       await window.hcp101SetupFixture?.close();
    136       window.hcp101Provider?.close();
    137     });
    138 });
    139 test('failed original setup disposal remains incomplete until actual retained cleanup is retried', async ({
    140   page
    141 }) => {
    142   await page.evaluate(async () => {
    143     window.hcp101Fixture = await window.hcp101.renderFixture(0);
    144   });
    145   const observed = await page.evaluate(() =>
    146     window.hcp101Fixture.retryFailedSetupClose()
    147   );
    148   console.log(
    149     'actual failed original setup disposal',
    150     JSON.stringify(observed)
    151   );
    152   expect(observed.first).toBe(false);
    153   expect(observed.incomplete).toBe(true);
    154   expect(observed.second).toBe(true);
    155   expect(observed.closedSetups).toBe(2);
    156   expect(observed.cleanupRequired).toBe(false);
    157   expect(events).toEqual([]);
    158   expect(requests).toEqual([]);
    159 });
    160 test('revoked original exercised access becomes partial while preserving the actual earlier checked time', async ({
    161   page
    162 }) => {
    163   await page.evaluate(async () => {
    164     window.hcp101Fixture = await window.hcp101.renderFixture(0, true);
    165     await window.hcp101Fixture.checkSetup();
    166     await window.hcp101Fixture.unlock();
    167     await window.hcp101Fixture.check();
    168   });
    169   await expect
    170     .poll(() => page.evaluate(() => window.hcp101Fixture.snapshot().state))
    171     .toBe('empty');
    172   const before = await page.evaluate(
    173     () => window.hcp101Fixture.snapshot().lastCheckedAt
    174   );
    175   const observed = await page.evaluate(() => {
    176     window.hcp101Fixture.revokeAccess();
    177     return window.hcp101Fixture.snapshot();
    178   });
    179   console.log(
    180     'actual revoked original exercised access',
    181     JSON.stringify(observed)
    182   );
    183   expect(observed.state).toBe('partial');
    184   expect(observed.reason).toBe('access_unavailable');
    185   expect(observed.lastCheckedAt).toBe(before);
    186   expect(events).toEqual([]);
    187 });
    188 test('actual production guest connection publishes no event and cannot claim an empty inbox', async ({
    189   page
    190 }) => {
    191   await page.goto(server.url + '/messages');
    192   await page.addScriptTag({ content: bundle });
    193   await expect(
    194     page
    195       .locator('#main-content')
    196       .getByRole('button', { name: 'Connect extension' })
    197   ).toBeVisible();
    198   await expect(
    199     page
    200       .locator('#main-content')
    201       .getByText('No messages found in the checked inbox history.')
    202   ).toHaveCount(0);
    203   await expect(
    204     page.locator('#main-content').getByText(/^Last checked/)
    205   ).toHaveCount(0);
    206   expect(events).toEqual([]);
    207   expect(requests).toEqual([]);
    208   await expect(page).toHaveTitle('HarvestCircle');
    209   await expect(page.locator('meta[name="robots"]')).toHaveCount(1);
    210 });
    211 test('actual missing NIP44 encrypt capability is explanatory and never an empty inbox', async ({
    212   page
    213 }) => {
    214   await page.goto(server.url + '/messages');
    215   await page.addScriptTag({ content: bundle });
    216   await page.evaluate(async () => {
    217     window.hcp101Provider = await window.hcp101.makeSetupFixture();
    218     const provider = window.nostr as
    219       { nip44?: { encrypt?: unknown } } | undefined;
    220     if (provider?.nip44) Reflect.deleteProperty(provider.nip44, 'encrypt');
    221   });
    222   const main = page.locator('#main-content');
    223   await main.getByRole('button', { name: 'Connect extension' }).click();
    224   await main.getByRole('button', { name: 'Check messaging support' }).click();
    225   await expect(
    226     main.getByText(
    227       'This extension does not support the required message encryption.'
    228     )
    229   ).toBeVisible();
    230   await expect(
    231     main.getByText('No messages found in the checked inbox history.')
    232   ).toHaveCount(0);
    233   expect(events).toEqual([]);
    234   expect(requests).toEqual([]);
    235 });
    236 test('existing genuine signed preference offers an explicit disclosed unlock without replacement or send', async ({
    237   page
    238 }) => {
    239   await page.evaluate(async () => {
    240     window.hcp101Fixture = await window.hcp101.renderFixture(21);
    241   });
    242   await page.getByRole('button', { name: 'Check current preference' }).click();
    243   await expect(
    244     page.getByRole('button', { name: 'Unlock messages', exact: true })
    245   ).toBeVisible();
    246   await expect(
    247     page.getByText(/Your extension will be asked to decrypt/)
    248   ).toBeVisible();
    249   await expect(
    250     page.getByRole('button', { name: 'Enable inbox', exact: true })
    251   ).toHaveCount(0);
    252   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    253     { decrypts: 0, signs: 0, encrypts: 0 }
    254   );
    255   expect(events).toEqual([]);
    256   expect(requests).toEqual([]);
    257 });
    258 test('actual missing preference is setup and completed absence never becomes an empty message list', async ({
    259   page
    260 }) => {
    261   await page.evaluate(async () => {
    262     window.hcp101SetupFixture =
    263       await window.hcp101.renderSetupFixture('missing');
    264   });
    265   await page.getByRole('button', { name: 'Check current preference' }).click();
    266   await expect(
    267     page.getByText(
    268       'No preference was observed in this completed bounded lookup. This does not prove global absence.'
    269     )
    270   ).toBeVisible();
    271   expect(
    272     await page.evaluate(() => window.hcp101SetupFixture.snapshot().state)
    273   ).toBe('setup');
    274   await expect(
    275     page.getByText('No messages found in the checked inbox history.')
    276   ).toHaveCount(0);
    277   await expect(page.getByText(/^Last checked/)).toHaveCount(0);
    278   expect(events).toEqual([]);
    279 });
    280 test('incomplete actual preference lookup stays unknown without unlock, checked time or fabricated absence', async ({
    281   page
    282 }) => {
    283   await page.evaluate(async () => {
    284     window.hcp101SetupFixture =
    285       await window.hcp101.renderSetupFixture('incomplete');
    286   });
    287   await page.getByRole('button', { name: 'Check current preference' }).click();
    288   await expect(
    289     page.getByText(
    290       'The lookup is incomplete. Your current inbox preference is unknown.'
    291     )
    292   ).toBeVisible();
    293   await expect(
    294     page.getByRole('button', { name: 'Unlock messages', exact: true })
    295   ).toHaveCount(0);
    296   await expect(page.getByText(/^Last checked/)).toHaveCount(0);
    297   expect(
    298     await page.evaluate(() => window.hcp101SetupFixture.counts().signs)
    299   ).toBe(0);
    300   expect(events).toEqual([]);
    301 });
    302 test('explicit original Unlock processes20 actual encrypted envelopes and waits for a second review for21st', async ({
    303   page
    304 }) => {
    305   await page.evaluate(async () => {
    306     window.hcp101Fixture = await window.hcp101.renderFixture(21);
    307     await window.hcp101Fixture.checkSetup();
    308   });
    309   await page
    310     .getByRole('button', { name: 'Unlock messages', exact: true })
    311     .click();
    312   await expect
    313     .poll(() => page.evaluate(() => window.hcp101Fixture.snapshot().queued))
    314     .toBe(1);
    315   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    316     { decrypts: 40, signs: 0, encrypts: 0 }
    317   );
    318   await expect(
    319     page.getByRole('button', { name: 'Read new messages (1)', exact: true })
    320   ).toBeVisible();
    321   expect(
    322     await page.evaluate(() => window.hcp101Fixture.encryptedUnchanged())
    323   ).toBe(true);
    324   await expect(page.getByText(/^Last checked/)).toHaveCount(0);
    325   expect(events).toEqual([]);
    326   expect(requests).toEqual([]);
    327 });
    328 test('a further explicit decrypt batch consumes only the remaining envelope and cannot send or rewrite', async ({
    329   page
    330 }) => {
    331   await page.evaluate(async () => {
    332     window.hcp101Fixture = await window.hcp101.renderFixture(21);
    333     await window.hcp101Fixture.checkSetup();
    334     await window.hcp101Fixture.unlock();
    335   });
    336   await page
    337     .getByRole('button', { name: 'Read new messages (1)', exact: true })
    338     .click();
    339   await expect
    340     .poll(() => page.evaluate(() => window.hcp101Fixture.snapshot().queued))
    341     .toBe(0);
    342   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    343     { decrypts: 42, signs: 0, encrypts: 0 }
    344   );
    345   expect(
    346     await page.evaluate(() => window.hcp101Fixture.encryptedUnchanged())
    347   ).toBe(true);
    348   await expect(
    349     page.getByRole('button', { name: /^Read new messages/ })
    350   ).toHaveCount(0);
    351   expect(events).toEqual([]);
    352 });
    353 test('unqualified real access remains partial and Check cannot mint checked time, empty state or private REQ', async ({
    354   page
    355 }) => {
    356   await page.evaluate(async () => {
    357     window.hcp101Fixture = await window.hcp101.renderFixture(0, false);
    358     await window.hcp101Fixture.checkSetup();
    359     await window.hcp101Fixture.unlock();
    360   });
    361   await page
    362     .getByRole('button', { name: 'Check for messages', exact: true })
    363     .click();
    364   expect(
    365     await page.evaluate(() => window.hcp101Fixture.snapshot())
    366   ).toMatchObject({
    367     state: 'partial',
    368     lastCheckedAt: null,
    369     count: 0,
    370     queued: 0
    371   });
    372   await expect(
    373     page.getByText('No messages found in the checked inbox history.')
    374   ).toHaveCount(0);
    375   await expect(page.getByText(/^Last checked/)).toHaveCount(0);
    376   expect(requests).toEqual([]);
    377   expect(events).toEqual([]);
    378 });
    379 test('only actual controlled qualified live-before-finite completion supplies a bounded empty state and checked time', async ({
    380   page
    381 }) => {
    382   await page.evaluate(async () => {
    383     window.hcp101Fixture = await window.hcp101.renderFixture(0, true);
    384     await window.hcp101Fixture.checkSetup();
    385     await window.hcp101Fixture.unlock();
    386   });
    387   expect(
    388     await page.evaluate(() => window.hcp101Fixture.snapshot().lastCheckedAt)
    389   ).toBeNull();
    390   await page
    391     .getByRole('button', { name: 'Check for messages', exact: true })
    392     .click();
    393   await expect(
    394     page.getByText('No messages found in the checked inbox history.')
    395   ).toBeVisible();
    396   await expect(page.getByText(/^Last checked/)).toBeVisible();
    397   expect(requests.length).toBe(3);
    398   expect((requests[0][2] as { limit: number }).limit).toBe(0);
    399   expect((requests[1][2] as { limit: number }).limit).toBe(200);
    400   expect((requests[2][2] as { limit: number }).limit).toBe(200);
    401   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    402     { decrypts: 0, signs: 0, encrypts: 0 }
    403   );
    404   expect(events).toEqual([]);
    405 });
    406 test('copied page tokens and mutable detached setup observations cannot acquire or change original custody', async ({
    407   page
    408 }) => {
    409   await page.evaluate(async () => {
    410     window.hcp101Fixture = await window.hcp101.renderFixture(0);
    411   });
    412   expect(await page.evaluate(() => window.hcp101Fixture.copied())).toEqual({
    413     unlock: false,
    414     check: false,
    415     next: false
    416   });
    417   expect(
    418     await page.evaluate(() => window.hcp101Fixture.mutateOwnership())
    419   ).toBe(true);
    420   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    421     { decrypts: 0, signs: 0, encrypts: 0 }
    422   );
    423   expect(events).toEqual([]);
    424   expect(requests).toEqual([]);
    425 });
    426 test('logout during held actual extension decryption clears presentation and prevents late cached admission', async ({
    427   page
    428 }) => {
    429   await page.evaluate(async () => {
    430     window.hcp101Fixture = await window.hcp101.renderFixture(1);
    431     await window.hcp101Fixture.checkSetup();
    432     window.hcp101Fixture.mode('hold_decrypt');
    433     window.hcp101Pending = window.hcp101Fixture.unlock();
    434   });
    435   await expect
    436     .poll(() => page.evaluate(() => window.hcp101Fixture.pending()))
    437     .toBe(true);
    438   await page.evaluate(() => window.hcp101Fixture.logout());
    439   expect(
    440     await page.evaluate(() => window.hcp101Fixture.snapshot())
    441   ).toMatchObject({
    442     state: 'unavailable',
    443     count: 0,
    444     queued: 0,
    445     lastCheckedAt: null
    446   });
    447   expect(
    448     await page.evaluate(() => window.hcp101Fixture.scheduler()?.state)
    449   ).toBe('active');
    450   await page.evaluate(async () => {
    451     window.hcp101Fixture.settle();
    452     await window.hcp101Pending;
    453   });
    454   expect(await page.evaluate(() => window.hcp101Fixture.snapshot().count)).toBe(
    455     0
    456   );
    457   expect(
    458     await page.evaluate(() => window.hcp101Fixture.snapshot())
    459   ).toMatchObject({
    460     state: 'unavailable',
    461     count: 0,
    462     queued: 0,
    463     lastCheckedAt: null
    464   });
    465   await expect(
    466     page.getByRole('button', { name: 'Read new messages (1)', exact: true })
    467   ).toHaveCount(0);
    468   await expect(page.getByText(/Last checked at/)).toHaveCount(0);
    469   expect(
    470     await page.evaluate(() => window.hcp101Fixture.encryptedUnchanged())
    471   ).toBe(true);
    472   expect(events).toEqual([]);
    473   expect(requests).toEqual([]);
    474 });
    475 test('a second explicit qualified Check performs fresh finite requests while preserving original live ownership', async ({
    476   page
    477 }) => {
    478   await page.evaluate(async () => {
    479     window.hcp101Fixture = await window.hcp101.renderFixture(0, true);
    480     await window.hcp101Fixture.checkSetup();
    481     await window.hcp101Fixture.unlock();
    482     await window.hcp101Fixture.check();
    483   });
    484   await expect
    485     .poll(() => page.evaluate(() => window.hcp101Fixture.snapshot().state))
    486     .toBe('empty');
    487   expect(requests.length).toBe(3);
    488   const before = await page.evaluate(
    489     () => window.hcp101Fixture.snapshot().lastCheckedAt
    490   );
    491   await page
    492     .getByRole('button', { name: 'Check for messages', exact: true })
    493     .click();
    494   await expect.poll(() => requests.length).toBe(5);
    495   await expect
    496     .poll(() => page.evaluate(() => window.hcp101Fixture.snapshot().state))
    497     .toBe('empty');
    498   expect(closes.length).toBeGreaterThanOrEqual(4);
    499   expect(
    500     await page.evaluate(() => window.hcp101Fixture.snapshot().lastCheckedAt)
    501   ).toBeGreaterThanOrEqual(before!);
    502   expect((requests[3][2] as { limit: number }).limit).toBe(200);
    503   expect((requests[4][2] as { limit: number }).limit).toBe(200);
    504   expect(await page.evaluate(() => window.hcp101Fixture.delta())).toMatchObject(
    505     { decrypts: 0, signs: 0, encrypts: 0 }
    506   );
    507   expect(events).toEqual([]);
    508 });