app

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

product-enquiry.spec.ts (18027B)


      1 import { test, expect, 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 { once } from 'node:events';
      6 import { WebSocketServer } from 'ws';
      7 import { finalizeEvent, getPublicKey } from 'applesauce-core/helpers';
      8 import { createStaticHarness } from '../integration/harness/static.ts';
      9 import type * as Fixture from './harness/product-enquiry.ts';
     10 declare global {
     11   interface Window {
     12     hcp106: typeof Fixture;
     13     hcp106Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>;
     14   }
     15 }
     16 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     17   sockets: WebSocketServer,
     18   endpoint: string,
     19   bundle: string;
     20 type Mode =
     21   | 'normal'
     22   | 'missing'
     23   | 'wrong_author'
     24   | 'wrong_coordinate'
     25   | 'invalid_signature'
     26   | 'sold'
     27   | 'deleted'
     28   | 'partial';
     29 let mode: Mode = 'normal',
     30   requests: unknown[][] = [],
     31   events: unknown[][] = [];
     32 const secret = new Uint8Array(32).fill(84),
     33   otherSecret = new Uint8Array(32).fill(90),
     34   peer = getPublicKey(secret);
     35 function listing(createdAt = 1700000060) {
     36   const event = finalizeEvent(
     37     {
     38       kind: 30402,
     39       created_at: createdAt,
     40       content: 'Independently signed carrots',
     41       tags: [
     42         ['d', mode === 'wrong_coordinate' ? 'apples' : 'carrots'],
     43         ['title', 'Verified carrots'],
     44         ['summary', 'Actual signed listing'],
     45         ['published_at', '1700000000'],
     46         ['location', 'Victoria'],
     47         ['price', '3.5', 'CAD'],
     48         ['radroots:price_unit', 'lb'],
     49         ['status', mode === 'sold' ? 'sold' : 'active']
     50       ]
     51     },
     52     mode === 'wrong_author' ? otherSecret : secret
     53   );
     54   return mode === 'invalid_signature'
     55     ? { ...event, sig: '0'.repeat(128) }
     56     : event;
     57 }
     58 test.beforeAll(async () => {
     59   server = await createStaticHarness();
     60   sockets = new WebSocketServer({
     61     host: '127.0.0.1',
     62     port: 0,
     63     maxPayload: 65536
     64   });
     65   await once(sockets, 'listening');
     66   const address = sockets.address();
     67   if (!address || typeof address === 'string') throw Error('no loopback');
     68   endpoint = 'ws://127.0.0.1:' + address.port;
     69   sockets.on('connection', (socket) =>
     70     socket.on('message', (bytes) => {
     71       const raw = Buffer.isBuffer(bytes)
     72         ? bytes
     73         : Array.isArray(bytes)
     74           ? Buffer.concat(bytes)
     75           : Buffer.from(bytes);
     76       const frame = JSON.parse(raw.toString()) as unknown[];
     77       if (frame[0] === 'EVENT') {
     78         events.push(frame);
     79         return;
     80       }
     81       if (frame[0] !== 'REQ') return;
     82       requests.push(frame);
     83       const filters = frame.slice(2) as { kinds?: number[]; ids?: string[] }[];
     84       const send = () => {
     85         if (mode !== 'missing') {
     86           if (filters.some((f) => f.kinds?.includes(0)))
     87             socket.send(
     88               JSON.stringify([
     89                 'EVENT',
     90                 frame[1],
     91                 finalizeEvent(
     92                   {
     93                     kind: 0,
     94                     created_at: 1700000060,
     95                     tags: [],
     96                     content: JSON.stringify({ name: 'Another display name' })
     97                   },
     98                   secret
     99                 )
    100               ])
    101             );
    102           if (filters.some((f) => f.kinds?.includes(30402))) {
    103             const exact = filters.find((f) => f.ids)?.ids;
    104             const event = exact?.includes(listing(1700000050).id)
    105               ? listing(1700000050)
    106               : listing();
    107             socket.send(JSON.stringify(['EVENT', frame[1], event]));
    108           }
    109           if (mode === 'deleted' && filters.some((f) => f.kinds?.includes(5)))
    110             socket.send(
    111               JSON.stringify([
    112                 'EVENT',
    113                 frame[1],
    114                 finalizeEvent(
    115                   {
    116                     kind: 5,
    117                     created_at: 1700000070,
    118                     tags: [['a', '30402:' + peer + ':carrots']],
    119                     content: ''
    120                   },
    121                   secret
    122                 )
    123               ])
    124             );
    125         }
    126         if (!(
    127           mode === 'partial' &&
    128           filters.some((filter) => filter.kinds?.includes(5))
    129         ))
    130           socket.send(JSON.stringify(['EOSE', frame[1]]));
    131       };
    132       send();
    133     })
    134   );
    135   const result = await build({
    136     configFile: false,
    137     logLevel: 'silent',
    138     plugins: [svelte({ configFile: false })],
    139     resolve: {
    140       conditions: ['browser'],
    141       alias: {
    142         '$app/navigation': fileURLToPath(
    143           new URL('./harness/product-enquiry.ts', import.meta.url)
    144         )
    145       }
    146     },
    147     build: {
    148       write: false,
    149       minify: false,
    150       lib: {
    151         entry: fileURLToPath(
    152           new URL('./harness/product-enquiry.ts', import.meta.url)
    153         ),
    154         name: 'hcp106',
    155         formats: ['iife']
    156       }
    157     }
    158   });
    159   const output = Array.isArray(result) ? result[0] : result;
    160   if (!('output' in output)) throw Error('no bundle');
    161   const chunks = output.output.filter((row) => row.type === 'chunk');
    162   expect(chunks).toHaveLength(1);
    163   bundle = chunks[0].code;
    164 });
    165 test.afterAll(async () => {
    166   for (const socket of sockets.clients) socket.terminate();
    167   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    168   await server.close();
    169 });
    170 test.beforeEach(async ({ page }) => {
    171   mode = 'normal';
    172   requests = [];
    173   events = [];
    174   await page.addInitScript(
    175     ({ endpoint }) => {
    176       const Native = window.WebSocket;
    177       window.WebSocket = class extends Native {
    178         constructor(url: string | URL, protocols?: string | string[]) {
    179           if (
    180             ![
    181               'wss://discovery.example.org',
    182               'wss://archive.example.org',
    183               'wss://peer.example.org'
    184             ].includes(new URL(String(url)).origin)
    185           )
    186             throw Error('unapproved destination');
    187           super(endpoint, protocols);
    188         }
    189       };
    190     },
    191     { endpoint }
    192   );
    193   await page.goto(server.url + '/search');
    194   await page.addScriptTag({ content: bundle });
    195 });
    196 
    197 test.afterEach(async ({ page }) => {
    198   if (!page.isClosed())
    199     await page.evaluate(() => window.hcp106Fixture?.close());
    200 });
    201 async function ready(page: Page, existing = false) {
    202   await page.evaluate(async (existing) => {
    203     window.hcp106Fixture = await window.hcp106.renderFixture(existing);
    204   }, existing);
    205   await expect(page.locator('[data-enquiry-fixture]')).toBeAttached();
    206   if (existing)
    207     await expect
    208       .poll(() =>
    209         page.evaluate(async () =>
    210           (await window.hcp106Fixture.native()).received.every(
    211             (row) =>
    212               (JSON.parse((row as { wire: string }).wire) as { read: unknown })
    213                 .read !== null
    214           )
    215         )
    216       )
    217       .toBe(true);
    218   await expect
    219     .poll(() =>
    220       page.evaluate(() => window.hcp106Fixture.viewSnapshot().outcome)
    221     )
    222     .not.toBe('checking');
    223 }
    224 const panel = (page: Page) => page.locator('[data-enquiry-fixture]');
    225 const open = (page: Page) =>
    226   panel(page)
    227     .getByRole('button', { name: 'Message seller', exact: true })
    228     .click();
    229 test('HCP108 a sold listing does not remove an original retained conversation or its UUID navigation', async ({
    230   page
    231 }) => {
    232   mode = 'sold';
    233   await ready(page, true);
    234   const actual = await page.evaluate(async () => ({
    235     listing: window.hcp106Fixture.viewSnapshot(),
    236     thread: window.hcp106Fixture.existingThread(),
    237     native: await window.hcp106Fixture.native(),
    238     path: await window.hcp106Fixture.resolveExistingThread(),
    239     known: window.hcp106Fixture.knownPath()
    240   }));
    241   expect(actual.listing.outcome).toBe('sold');
    242   expect(actual.thread?.status).toBe('ready');
    243   expect(actual.thread?.messages.length).toBeGreaterThan(0);
    244   expect(actual.native.received.length).toBeGreaterThan(0);
    245   expect(actual.native.pairs.length).toBeGreaterThan(0);
    246   expect(actual.path).toBe(true);
    247   expect(actual.known).toMatch(/^\/messages\/[a-f0-9-]{36}$/);
    248   expect(await page.evaluate(() => window.hcp106Fixture.capture())).toBe(false);
    249 });
    250 test('explicit guest enquiry captures the signed publisher and readable viewed context without connection or Send', async ({
    251   page
    252 }) => {
    253   await ready(page);
    254   const before = requests.length;
    255   await expect(
    256     panel(page).getByRole('textbox', { name: 'Your message', exact: true })
    257   ).toHaveCount(0);
    258   await open(page);
    259   await expect(
    260     panel(page).getByRole('textbox', { name: 'Your message', exact: true })
    261   ).toBeVisible();
    262   await expect(panel(page)).toContainText('Verified carrots');
    263   await expect(panel(page)).toContainText(peer);
    264   await expect(panel(page)).toContainText('not a confirmed order');
    265   expect(await page.evaluate(() => window.hcp106Fixture.snapshot()?.peer)).toBe(
    266     peer
    267   );
    268   expect(requests).toHaveLength(before);
    269   expect(events).toEqual([]);
    270   expect(await page.evaluate(() => window.hcp106Fixture.delta())).toEqual({
    271     decrypts: 0,
    272     signs: 0,
    273     encrypts: 0
    274   });
    275 });
    276 test('exact canonical coordinate and signed listing version survive capture and the first message has no parent', async ({
    277   page
    278 }) => {
    279   await ready(page);
    280   await open(page);
    281   const actual = await page.evaluate(() => ({
    282     snapshot: window.hcp106Fixture.snapshot(),
    283     message: window.hcp106Fixture.message()
    284   }));
    285   expect(actual.snapshot?.eventId).toBe(listing().id);
    286   expect(actual.message?.tags).toEqual([['p', peer]]);
    287   expect(actual.message?.content).toContain('nostr:' + actual.snapshot?.naddr);
    288   expect(actual.message?.content).toContain('nostr:' + actual.snapshot?.nevent);
    289   expect(actual.message?.content).toContain('3.5 CAD/lb');
    290   expect(actual.message?.content).toContain('not a confirmed order');
    291   expect(
    292     actual.message?.tags.some((tag) =>
    293       ['e', 'a', 'q', 'order', 'thread'].includes(tag[0])
    294     )
    295   ).toBe(false);
    296   expect(events).toEqual([]);
    297 });
    298 test('editable amount timing and fake recipient assertions never change the publisher references or inventory', async ({
    299   page
    300 }) => {
    301   await ready(page, true);
    302   const before = await page.evaluate(() => window.hcp106Fixture.native());
    303   await open(page);
    304   const text = '2 kg Thursday. Send to ' + getPublicKey(otherSecret);
    305   await panel(page)
    306     .getByRole('textbox', { name: 'Your message', exact: true })
    307     .fill(text);
    308   const message = await page.evaluate(() => window.hcp106Fixture.message());
    309   expect(message?.tags).toEqual([['p', peer]]);
    310   expect(message?.content).toContain(text);
    311   expect(message?.content).toContain('nostr:');
    312   expect(await page.evaluate(() => window.hcp106Fixture.native())).toEqual(
    313     before
    314   );
    315   expect(await page.evaluate(() => window.hcp106Fixture.delta())).toEqual({
    316     decrypts: 0,
    317     signs: 0,
    318     encrypts: 0
    319   });
    320   expect(events).toEqual([]);
    321 });
    322 test('a display name never becomes recipient authority or creates a shop route', async ({
    323   page
    324 }) => {
    325   await ready(page);
    326   await open(page);
    327   expect(
    328     await page.evaluate(() => window.hcp106Fixture.message()?.tags)
    329   ).toEqual([['p', peer]]);
    330   expect(
    331     await panel(page)
    332       .locator('a[href*="/shops/"],a[href*="/profiles/"]')
    333       .count()
    334   ).toBe(0);
    335   expect(events).toEqual([]);
    336 });
    337 test('only an actual admitted original pair can be explicitly reused without a new UUID or message parent', async ({
    338   page
    339 }) => {
    340   await ready(page, true);
    341   const before = await page.evaluate(() => window.hcp106Fixture.native());
    342   await open(page);
    343   expect(await page.evaluate(() => window.hcp106Fixture.reuse())).toBe(
    344     await page.evaluate(() => window.hcp106Fixture.knownPath())
    345   );
    346   expect(await page.evaluate(() => window.hcp106Fixture.native())).toEqual(
    347     before
    348   );
    349   expect(
    350     await page.evaluate(() => window.hcp106Fixture.message()?.tags)
    351   ).toEqual([['p', peer]]);
    352   expect(events).toEqual([]);
    353 });
    354 test('copied view enquiry and inbox tokens cannot borrow publisher private draft or conversation authority', async ({
    355   page
    356 }) => {
    357   await ready(page, true);
    358   await open(page);
    359   const before = await page.evaluate(() => window.hcp106Fixture.native());
    360   expect(await page.evaluate(() => window.hcp106Fixture.copied())).toEqual({
    361     view: false,
    362     snapshot: undefined,
    363     message: undefined,
    364     update: false,
    365     reuse: undefined
    366   });
    367   expect(await page.evaluate(() => window.hcp106Fixture.native())).toEqual(
    368     before
    369   );
    370   expect(events).toEqual([]);
    371 });
    372 test('unreviewed capture editing and reuse do not change the original memory-only draft', async ({
    373   page
    374 }) => {
    375   await ready(page, true);
    376   await open(page);
    377   const before = await page.evaluate(() => window.hcp106Fixture.snapshot());
    378   expect(await page.evaluate(() => window.hcp106Fixture.unreviewed())).toEqual({
    379     capture: false,
    380     update: false,
    381     reuse: undefined
    382   });
    383   expect(await page.evaluate(() => window.hcp106Fixture.snapshot())).toEqual(
    384     before
    385   );
    386   expect(events).toEqual([]);
    387 });
    388 test('private draft text is absent from URLs local storage and actual native persistence', async ({
    389   page
    390 }) => {
    391   await ready(page, true);
    392   await open(page);
    393   const text = 'PRIVATE HCP106 guest enquiry zebra';
    394   await panel(page)
    395     .getByRole('textbox', { name: 'Your message', exact: true })
    396     .fill(text);
    397   expect(
    398     await page.evaluate(() => window.hcp106Fixture.persistentText())
    399   ).not.toContain(text);
    400   expect(events).toEqual([]);
    401 });
    402 test('closing the original product view invalidates its draft and cannot produce a later message', async ({
    403   page
    404 }) => {
    405   await ready(page);
    406   await open(page);
    407   await page.evaluate(() => window.hcp106Fixture.closeView());
    408   expect(
    409     await page.evaluate(() => window.hcp106Fixture.snapshot())
    410   ).toBeUndefined();
    411   expect(
    412     await page.evaluate(() => window.hcp106Fixture.message())
    413   ).toBeUndefined();
    414   expect(await page.evaluate(() => window.hcp106Fixture.update('late'))).toBe(
    415     false
    416   );
    417   expect(events).toEqual([]);
    418 });
    419 for (const rejection of [
    420   'missing',
    421   'wrong_author',
    422   'wrong_coordinate',
    423   'invalid_signature',
    424   'sold',
    425   'deleted'
    426 ] as const)
    427   test(
    428     'unavailable or untrusted listing cannot allocate an enquiry: ' + rejection,
    429     async ({ page }) => {
    430       mode = rejection;
    431       await ready(page);
    432       expect(
    433         await page.evaluate(() => window.hcp106Fixture.viewSnapshot().outcome)
    434       ).toBe(
    435         rejection === 'sold'
    436           ? 'sold'
    437           : rejection === 'deleted'
    438             ? 'withdrawn'
    439             : 'unobserved'
    440       );
    441       await expect(
    442         panel(page).getByRole('button', { name: 'Message seller', exact: true })
    443       ).toHaveCount(0);
    444       expect(await page.evaluate(() => window.hcp106Fixture.capture())).toBe(
    445         false
    446       );
    447       expect(
    448         await page.evaluate(() => window.hcp106Fixture.message())
    449       ).toBeUndefined();
    450       await expect(
    451         panel(page).getByRole('textbox', { name: 'Your message', exact: true })
    452       ).toHaveCount(0);
    453       expect(events).toEqual([]);
    454     }
    455   );
    456 test('incomplete deletion coverage is not silently admitted as current enquiry context', async ({
    457   page
    458 }) => {
    459   mode = 'partial';
    460   await ready(page);
    461   await page.evaluate(() => window.hcp106Fixture.advance());
    462   expect(
    463     await page.evaluate(() => window.hcp106Fixture.viewSnapshot().lastKnown)
    464   ).toBe(true);
    465   expect(await page.evaluate(() => window.hcp106Fixture.capture())).toBe(false);
    466   expect(events).toEqual([]);
    467 });
    468 
    469 test('original Close revokes mounted private guest text and request controls without side effects', async ({
    470   page
    471 }) => {
    472   await ready(page, true);
    473   await open(page);
    474   const text = 'PRIVATE HCP106 terminal guest text';
    475   await panel(page)
    476     .getByRole('textbox', { name: 'Your message', exact: true })
    477     .fill(text);
    478   const before = await page.evaluate(async () => ({
    479     native: await window.hcp106Fixture.native(),
    480     delta: window.hcp106Fixture.delta()
    481   }));
    482   const queryCount = requests.length;
    483   await page.evaluate(() => window.hcp106Fixture.closeView());
    484   expect(
    485     await page.evaluate(() => window.hcp106Fixture.message())
    486   ).toBeUndefined();
    487   expect(
    488     await panel(page)
    489       .getByRole('textbox', { name: 'Your message', exact: true })
    490       .count()
    491   ).toBe(0);
    492   expect(
    493     await panel(page)
    494       .getByRole('button', { name: 'Send request', exact: true })
    495       .count()
    496   ).toBe(0);
    497   expect(await panel(page).textContent()).not.toContain(text);
    498   expect(await panel(page).textContent()).not.toContain('Viewed listing:');
    499   expect(
    500     await page.evaluate(async () => ({
    501       native: await window.hcp106Fixture.native(),
    502       delta: window.hcp106Fixture.delta()
    503     }))
    504   ).toEqual(before);
    505   expect(requests).toHaveLength(queryCount);
    506   expect(events).toEqual([]);
    507 });
    508 
    509 test('ordinary original finite run expiry preserves an already captured unsent guest draft', async ({
    510   page
    511 }) => {
    512   await ready(page);
    513   await open(page);
    514   const text = 'PRIVATE HCP106 unsent after finite run';
    515   await panel(page)
    516     .getByRole('textbox', { name: 'Your message', exact: true })
    517     .fill(text);
    518   const queryCount = requests.length;
    519   await page.evaluate(() => window.hcp106Fixture.advance());
    520   expect(await page.evaluate(() => window.hcp106Fixture.snapshot()?.text)).toBe(
    521     text
    522   );
    523   expect(
    524     await page.evaluate(() => window.hcp106Fixture.snapshot()?.listingCurrent)
    525   ).toBe(false);
    526   expect(
    527     await page.evaluate(() => window.hcp106Fixture.message())
    528   ).toBeUndefined();
    529   await expect(
    530     panel(page).getByRole('textbox', { name: 'Your message', exact: true })
    531   ).toHaveValue(text);
    532   await expect(panel(page)).toContainText(
    533     'Listing status needs review. Your unsent text is kept in memory.'
    534   );
    535   expect(
    536     await page.evaluate(() =>
    537       window.hcp106Fixture.update('Still editing after expiry')
    538     )
    539   ).toBe(true);
    540   await expect(
    541     panel(page).getByRole('textbox', { name: 'Your message', exact: true })
    542   ).toHaveValue('Still editing after expiry');
    543   expect(
    544     await page.evaluate(() => window.hcp106Fixture.message())
    545   ).toBeUndefined();
    546   expect(requests).toHaveLength(queryCount);
    547   expect(events).toEqual([]);
    548 });