app

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

listing-continuity.spec.ts (19785B)


      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/listing-continuity.ts';
      7 import type { PublicDraftRecord } from '../../src/lib/contracts/local-records.ts';
      8 declare global {
      9   interface Window {
     10     hcp116: typeof Fixture;
     11     hcp116Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>;
     12     hcp116Observation: ReturnType<typeof Fixture.nativeObservation>;
     13     hcp116Abort: ReturnType<typeof Fixture.abortDraftWrites>;
     14     hcp116Unknown: ReturnType<typeof Fixture.unknownDraftAcknowledgment>;
     15     hcp116Input: HTMLInputElement;
     16   }
     17 }
     18 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     19 const form = {
     20   title: 'Exact incomplete draft',
     21   description: '  Raw description\n',
     22   location: '',
     23   amount: '2,50',
     24   currency: '',
     25   unit: 'kg',
     26   quantity: '03',
     27   contactType: '',
     28   contactValue: ''
     29 } as const;
     30 test.beforeAll(async () => {
     31   server = await createStaticHarness();
     32   const built = await build({
     33     configFile: false,
     34     plugins: [svelte({ configFile: false })],
     35     resolve: { conditions: ['browser'] },
     36     logLevel: 'silent',
     37     build: {
     38       write: false,
     39       minify: false,
     40       lib: {
     41         entry: fileURLToPath(
     42           new URL('./harness/listing-continuity.ts', import.meta.url)
     43         ),
     44         name: 'hcp116',
     45         formats: ['iife']
     46       }
     47     }
     48   });
     49   const output = Array.isArray(built) ? built[0] : built;
     50   if (!('output' in output)) throw Error('actual bundle missing');
     51   const chunks = output.output.filter((row) => row.type === 'chunk');
     52   expect(chunks).toHaveLength(1);
     53   bundle = chunks[0].code;
     54 });
     55 test.afterAll(async () => {
     56   await server?.close();
     57 });
     58 test.beforeEach(async ({ page }) => {
     59   await page.addInitScript(() => {
     60     window.WebSocket = class extends WebSocket {
     61       constructor() {
     62         super(
     63           (() => {
     64             throw Error('HCP116 source tests authorize no relay traffic');
     65           })()
     66         );
     67       }
     68     };
     69   });
     70   await page.goto(server.url + '/search');
     71   await page.addScriptTag({ content: bundle });
     72   await page.evaluate(async () => {
     73     window.hcp116Fixture = await window.hcp116.createFixture();
     74   });
     75 });
     76 test.afterEach(async ({ page }) => {
     77   await page.evaluate(async () => {
     78     window.hcp116Observation?.restore();
     79     window.hcp116Abort?.restore();
     80     window.hcp116Unknown?.release();
     81     await window.hcp116Fixture?.close();
     82   });
     83 });
     84 async function navigate(page: Page, pathname: string) {
     85   await page.evaluate((pathname) => {
     86     const a = document.createElement('a');
     87     a.id = 'hcp116-route';
     88     a.href = pathname;
     89     a.textContent = 'HCP116 controlled local route';
     90     document.body.append(a);
     91   }, pathname);
     92   await page.locator('#hcp116-route').click();
     93   await expect(page).toHaveURL(server.url + pathname);
     94   await page.evaluate(() => document.querySelector('#hcp116-route')?.remove());
     95 }
     96 async function newRoute(page: Page) {
     97   await navigate(page, '/sell');
     98   await page
     99     .getByRole('button', { name: 'Connect extension', exact: true })
    100     .last()
    101     .click();
    102   await expect(page.locator('main form')).toBeVisible();
    103 }
    104 async function drafts(page: Page) {
    105   const rows = await page.evaluate(
    106     async () =>
    107       (await window.hcp116.inspectNative()).drafts as { wire: string }[]
    108   );
    109   return rows.map((row) => JSON.parse(row.wire) as PublicDraftRecord);
    110 }
    111 test('HCP116 genuine first acknowledged save replaces entry URL with same original DOM focus and one durable draft', async ({
    112   page
    113 }) => {
    114   await newRoute(page);
    115   const field = page.getByLabel('Product name', { exact: true });
    116   await page.evaluate(() => {
    117     window.hcp116Input = document.querySelector(
    118       '#listing-title'
    119     ) as HTMLInputElement;
    120   });
    121   await field.fill(form.title);
    122   await expect(page).toHaveURL(/\/selling\/drafts\/[0-9a-f-]{36}$/);
    123   await expect(field).toBeFocused();
    124   expect(
    125     await page.evaluate(
    126       () => window.hcp116Input === document.querySelector('#listing-title')
    127     )
    128   ).toBe(true);
    129   const rows = await drafts(page);
    130   expect(rows).toHaveLength(1);
    131   expect(new URL(page.url()).pathname).toBe('/selling/drafts/' + rows[0].id);
    132   expect(rows[0].form.title).toBe(form.title);
    133   await field.fill('Later exact input');
    134   await expect(
    135     page.getByText('Saved in this browser.', { exact: true })
    136   ).toBeVisible();
    137   const later = await drafts(page);
    138   expect(later).toHaveLength(1);
    139   expect(later[0].id).toBe(rows[0].id);
    140   expect(later[0].form.title).toBe('Later exact input');
    141 });
    142 test('HCP116 held first native acknowledgment preserves latest edits focus and original id without another draft', async ({
    143   page
    144 }) => {
    145   await newRoute(page);
    146   await page.evaluate(() => {
    147     window.hcp116Observation = window.hcp116.nativeObservation();
    148     window.hcp116Observation.holdSave();
    149     window.hcp116Input = document.querySelector(
    150       '#listing-title'
    151     ) as HTMLInputElement;
    152   });
    153   const title = page.getByLabel('Product name', { exact: true });
    154   await title.fill('First captured input');
    155   await expect
    156     .poll(
    157       async () =>
    158         await page.evaluate(() => window.hcp116Observation.state().held)
    159     )
    160     .toBe(true);
    161   await title.fill('Latest input while original acknowledgment waits');
    162   await expect(page).toHaveURL(server.url + '/sell');
    163   await page.evaluate(() => window.hcp116Observation.release());
    164   await expect(page).toHaveURL(/\/selling\/drafts\/[0-9a-f-]{36}$/);
    165   await expect(title).toHaveValue(
    166     'Latest input while original acknowledgment waits'
    167   );
    168   await expect(title).toBeFocused();
    169   expect(
    170     await page.evaluate(
    171       () => window.hcp116Input === document.querySelector('#listing-title')
    172     )
    173   ).toBe(true);
    174   const rows = await drafts(page);
    175   expect(rows).toHaveLength(1);
    176   expect(rows[0].form.title).toBe(
    177     'Latest input while original acknowledgment waits'
    178   );
    179 });
    180 test('HCP116 durable draft URL reload and actual Search Back resume exact original raw values', async ({
    181   page
    182 }) => {
    183   await newRoute(page);
    184   await page.getByLabel('Product name', { exact: true }).fill(form.title);
    185   await expect(page).toHaveURL(/\/selling\/drafts\/[0-9a-f-]{36}$/);
    186   await page.getByLabel('Price', { exact: true }).fill(form.amount);
    187   await page.getByLabel('Per', { exact: true }).selectOption('kg');
    188   await page
    189     .getByLabel('Advertised quantity (optional)', { exact: true })
    190     .fill('03');
    191   await expect(
    192     page.getByText('Saved in this browser.', { exact: true })
    193   ).toBeVisible();
    194   const target = page.url(),
    195     before = await drafts(page);
    196   await page.getByRole('link', { name: 'Search', exact: true }).click();
    197   await expect(page.getByLabel('What are you looking for?')).toBeVisible();
    198   await page.goBack();
    199   await expect(page).toHaveURL(target);
    200   await expect(page.getByLabel('Price', { exact: true })).toHaveValue('2,50');
    201   await expect(
    202     page.getByLabel('Advertised quantity (optional)', { exact: true })
    203   ).toHaveValue('03');
    204   expect(await drafts(page)).toEqual(before);
    205   // TEST_ONLY same observed author after real reload; this controlled provider
    206   // offers no signature, relay or extension qualification.
    207   await page.addInitScript(
    208     (owner) =>
    209       Object.defineProperty(window, 'nostr', {
    210         configurable: true,
    211         value: {
    212           getPublicKey: () => Promise.resolve(owner),
    213           signEvent: () =>
    214             Promise.reject(
    215               Error('HCP116 reload asserts no signature capability')
    216             )
    217         }
    218       }),
    219     before[0].owner
    220   );
    221   await page.evaluate(async () => await window.hcp116Fixture.close());
    222   await page.reload();
    223   await page.addScriptTag({ content: bundle });
    224   await page
    225     .getByRole('button', { name: 'Connect extension', exact: true })
    226     .last()
    227     .click();
    228   await expect(page).toHaveURL(target);
    229   await expect(page.getByLabel('Price', { exact: true })).toHaveValue('2,50');
    230   await expect(
    231     page.getByLabel('Advertised quantity (optional)', { exact: true })
    232   ).toHaveValue('03');
    233   expect(await drafts(page)).toEqual(before);
    234 });
    235 test('HCP116 Save and close waits for genuine original acknowledgment and flushes latest input before Selling', async ({
    236   page
    237 }) => {
    238   await newRoute(page);
    239   await page.evaluate(() => {
    240     window.hcp116Observation = window.hcp116.nativeObservation();
    241     window.hcp116Observation.holdSave();
    242   });
    243   await page
    244     .getByLabel('Product name', { exact: true })
    245     .fill('Initial close input');
    246   await expect
    247     .poll(
    248       async () =>
    249         await page.evaluate(() => window.hcp116Observation.state().held)
    250     )
    251     .toBe(true);
    252   await page
    253     .getByRole('button', { name: 'Save and close', exact: true })
    254     .click();
    255   await expect(page).toHaveURL(server.url + '/sell');
    256   await page
    257     .getByLabel('Description', { exact: true })
    258     .fill('Latest exact close description\n');
    259   await page.evaluate(() => window.hcp116Observation.release());
    260   await expect(page).toHaveURL(server.url + '/selling');
    261   const rows = await drafts(page);
    262   expect(rows).toHaveLength(1);
    263   expect(rows[0].form.description).toBe('Latest exact close description\n');
    264 });
    265 test('HCP116 genuine native abort keeps current form and route until explicit Save and close succeeds', async ({
    266   page
    267 }) => {
    268   await newRoute(page);
    269   await page.evaluate(() => {
    270     window.hcp116Abort = window.hcp116.abortDraftWrites();
    271   });
    272   await page.getByLabel('Product name', { exact: true }).fill(form.title);
    273   await expect(
    274     page.getByText('Not saved. Keep your current input here.', { exact: true })
    275   ).toBeVisible();
    276   await page
    277     .getByRole('button', { name: 'Save and close', exact: true })
    278     .click();
    279   await expect(
    280     page.getByText('Not saved. Keep your current input here.', { exact: true })
    281   ).toBeVisible();
    282   await expect(page).toHaveURL(server.url + '/sell');
    283   await expect(page.getByLabel('Product name', { exact: true })).toHaveValue(
    284     form.title
    285   );
    286   expect(await drafts(page)).toHaveLength(0);
    287   const attempted = await page.evaluate(() => window.hcp116Abort.state());
    288   expect(attempted.aborts).toBeGreaterThan(0);
    289   expect(new Set(attempted.ids).size).toBe(1);
    290   await page.evaluate(() => window.hcp116Abort.restore());
    291   await page
    292     .getByRole('button', { name: 'Save and close', exact: true })
    293     .click();
    294   await expect(page).toHaveURL(server.url + '/selling');
    295   const rows = await drafts(page);
    296   expect(rows).toHaveLength(1);
    297   expect(rows[0].id).toBe(attempted.ids[0]);
    298   expect(rows[0].form.title).toBe(form.title);
    299 });
    300 test('HCP116 actual lost put and readback acknowledgments preserve original attempt then reconcile before latest save-close', async ({
    301   page
    302 }) => {
    303   await newRoute(page);
    304   await page.evaluate(() => {
    305     window.hcp116Unknown = window.hcp116.unknownDraftAcknowledgment();
    306   });
    307   await page
    308     .getByLabel('Product name', { exact: true })
    309     .fill('Original uncertain input');
    310   await expect(
    311     page.getByText('Not saved. Keep your current input here.', { exact: true })
    312   ).toBeVisible();
    313   await expect(page).toHaveURL(server.url + '/sell');
    314   const before = await drafts(page);
    315   expect(before).toHaveLength(1);
    316   await page
    317     .getByLabel('Product name', { exact: true })
    318     .fill('Latest input after unknown receipt');
    319   await expect(page.getByLabel('Product name', { exact: true })).toHaveValue(
    320     'Latest input after unknown receipt'
    321   );
    322   const actual = await page.evaluate(() => window.hcp116Unknown.state());
    323   expect(actual.puts).toBe(1);
    324   expect(actual.held).toBeGreaterThanOrEqual(2);
    325   await page.evaluate(() => window.hcp116Unknown.release());
    326   await page
    327     .getByRole('button', { name: 'Save and close', exact: true })
    328     .click();
    329   await expect(page).toHaveURL(server.url + '/selling');
    330   const after = await drafts(page);
    331   expect(after).toHaveLength(1);
    332   expect(after[0].id).toBe(before[0].id);
    333   expect(after[0].form.title).toBe('Latest input after unknown receipt');
    334 });
    335 test('HCP116 copied save-close cannot close original saved controller or create another draft', async ({
    336   page
    337 }) => {
    338   const actual = await page.evaluate(async (form) => {
    339     const f = window.hcp116Fixture;
    340     await f.open({ mode: 'new' });
    341     if (!(await f.edit(form))) throw Error('actual draft failed');
    342     const before = await f.inspect(),
    343       copied = await f.saveClose(true),
    344       originalAlive = !!f.snapshot(),
    345       original = await f.saveClose();
    346     return {
    347       before,
    348       copied,
    349       originalAlive,
    350       original,
    351       snapshot: f.snapshot(),
    352       after: await f.inspect()
    353     };
    354   }, form);
    355   expect(actual).toMatchObject({
    356     copied: false,
    357     originalAlive: true,
    358     original: true
    359   });
    360   expect(actual.snapshot).toBeUndefined();
    361   expect(actual.after).toEqual(actual.before);
    362 });
    363 test('HCP116 disconnected original editor cannot save-close through stale original ownership', async ({
    364   page
    365 }) => {
    366   const actual = await page.evaluate(async (form) => {
    367     const f = window.hcp116Fixture;
    368     await f.open({ mode: 'new' });
    369     await f.edit(form);
    370     const before = await f.inspect();
    371     f.disconnect();
    372     return {
    373       closed: await f.saveClose(),
    374       before,
    375       after: await f.inspect(),
    376       snapshot: f.snapshot()
    377     };
    378   }, form);
    379   expect(actual.closed).toBe(false);
    380   expect(actual.snapshot).toBeUndefined();
    381   expect(actual.after).toEqual(actual.before);
    382 });
    383 test('HCP116 logout while original save-close waits prevents late Selling navigation and leaves genuine local fact', async ({
    384   page
    385 }) => {
    386   await newRoute(page);
    387   await page.evaluate(() => {
    388     window.hcp116Observation = window.hcp116.nativeObservation();
    389     window.hcp116Observation.holdSave();
    390   });
    391   await page.getByLabel('Product name', { exact: true }).fill(form.title);
    392   await expect
    393     .poll(
    394       async () =>
    395         await page.evaluate(() => window.hcp116Observation.state().held)
    396     )
    397     .toBe(true);
    398   await page
    399     .getByRole('button', { name: 'Save and close', exact: true })
    400     .click();
    401   await page.getByText('Identity', { exact: true }).click();
    402   await page
    403     .getByRole('button', { name: 'Disconnect', exact: true })
    404     .first()
    405     .click();
    406   await page.evaluate(() => window.hcp116Observation.release());
    407   await expect(page.locator('main form')).toHaveCount(0);
    408   await expect(page).toHaveURL(server.url + '/sell');
    409   expect(await drafts(page)).toHaveLength(1);
    410 });
    411 test('HCP116 missing draft stays unavailable with safe Selling link and no empty substitute', async ({
    412   page
    413 }) => {
    414   await navigate(page, '/selling/drafts/' + crypto.randomUUID());
    415   await page
    416     .getByRole('button', { name: 'Connect extension', exact: true })
    417     .last()
    418     .click();
    419   await expect(
    420     page.getByText('This draft is not available here.', { exact: true })
    421   ).toBeVisible();
    422   await expect(
    423     page.getByRole('link', { name: 'Back to Selling', exact: true })
    424   ).toHaveAttribute('href', '/selling');
    425   await expect(page.locator('main form')).toHaveCount(0);
    426   await expect(
    427     page.getByRole('button', { name: 'Save and close', exact: true })
    428   ).toHaveCount(0);
    429   expect(await drafts(page)).toHaveLength(0);
    430 });
    431 test('HCP116 leaving route during original save-close prevents late Selling navigation', async ({
    432   page
    433 }) => {
    434   await newRoute(page);
    435   await page.evaluate(() => {
    436     window.hcp116Observation = window.hcp116.nativeObservation();
    437     window.hcp116Observation.holdSave();
    438   });
    439   await page.getByLabel('Product name', { exact: true }).fill(form.title);
    440   await expect
    441     .poll(
    442       async () =>
    443         await page.evaluate(() => window.hcp116Observation.state().held)
    444     )
    445     .toBe(true);
    446   await page
    447     .getByRole('button', { name: 'Save and close', exact: true })
    448     .click();
    449   await navigate(page, '/search');
    450   await page.evaluate(() => window.hcp116Observation.release());
    451   await expect(page).toHaveURL(server.url + '/search');
    452   await expect(page.locator('#listing-title')).toHaveCount(0);
    453   expect(await drafts(page)).toHaveLength(1);
    454 });
    455 test('HCP116 overlapping original save-close calls acknowledge latest input only once', async ({
    456   page
    457 }) => {
    458   await page.evaluate(async (form) => {
    459     const f = window.hcp116Fixture;
    460     await f.open({ mode: 'new' });
    461     window.hcp116Observation = window.hcp116.nativeObservation();
    462     window.hcp116Observation.holdSave();
    463     void f.edit(form);
    464   }, form);
    465   await expect
    466     .poll(
    467       async () =>
    468         await page.evaluate(() => window.hcp116Observation.state().held)
    469     )
    470     .toBe(true);
    471   const actual = await page.evaluate(async (form) => {
    472     const f = window.hcp116Fixture,
    473       first = f.saveClose(),
    474       second = f.saveClose();
    475     void f.edit({ ...form, title: 'Latest overlapping input' });
    476     window.hcp116Observation.release();
    477     return {
    478       results: await Promise.all([first, second]),
    479       rows: await f.inspect(),
    480       snapshot: f.snapshot()
    481     };
    482   }, form);
    483   expect(actual.results.filter(Boolean)).toHaveLength(1);
    484   expect(actual.snapshot).toBeUndefined();
    485   expect(actual.rows.drafts).toHaveLength(1);
    486   expect(
    487     (
    488       JSON.parse(
    489         (actual.rows.drafts[0] as { wire: string }).wire
    490       ) as PublicDraftRecord
    491     ).form.title
    492   ).toBe('Latest overlapping input');
    493 });
    494 for (const unknown of [false, true])
    495   test(`HCP116 genuine ${unknown ? 'unknown signing' : 'signed retained'} operation state prevents an apparently fresh draft submission`, async ({
    496     page
    497   }) => {
    498     const original = await page.evaluate(
    499       async (unknown) => await window.hcp116Fixture.captured(unknown),
    500       unknown
    501     );
    502     const before = await page.evaluate(
    503       async () => await window.hcp116Fixture.inspect()
    504     );
    505     await navigate(page, '/selling/drafts/' + original.draftId);
    506     await page
    507       .getByRole('button', { name: 'Connect extension', exact: true })
    508       .last()
    509       .click();
    510     await expect(page.locator('main form')).toBeVisible();
    511     await expect(
    512       page.getByLabel('Product name', { exact: true })
    513     ).toHaveAttribute('readonly', '');
    514     await expect(
    515       page.getByText(
    516         unknown
    517           ? 'The outcome is unknown. Keep the original listing operation for reconciliation.'
    518           : 'Signed listing saved in this browser. No relay acceptance is recorded.',
    519         { exact: true }
    520       )
    521     ).toBeVisible();
    522     await expect(
    523       page.getByRole('button', { name: 'Save and close', exact: true })
    524     ).toHaveCount(0);
    525     await expect(
    526       page.getByRole('button', { name: 'Review listing', exact: true })
    527     ).toHaveCount(0);
    528     expect(
    529       await page.evaluate(async () => await window.hcp116Fixture.inspect())
    530     ).toEqual(before);
    531   });
    532 
    533 test('HCP116 foreign genuine draft exposes only unavailable state and safe Selling link, never resets data', async ({
    534   page
    535 }) => {
    536   const original = await page.evaluate(async () => {
    537     const captured = await window.hcp116Fixture.captured();
    538     const rows = await window.hcp116Fixture.inspect();
    539     await window.hcp116Fixture.close();
    540     window.hcp116Fixture = await window.hcp116.createFixture();
    541     return { captured, rows };
    542   });
    543   await navigate(page, '/selling/drafts/' + original.captured.draftId);
    544   await page
    545     .getByRole('button', { name: 'Connect extension', exact: true })
    546     .last()
    547     .click();
    548   await expect(
    549     page.getByText('This draft is not available here.', { exact: true })
    550   ).toBeVisible();
    551   await expect(
    552     page.getByRole('link', { name: 'Back to Selling', exact: true })
    553   ).toHaveAttribute('href', '/selling');
    554   await expect(page.locator('main form')).toHaveCount(0);
    555   expect(
    556     await page.evaluate(async () => await window.hcp116Fixture.inspect())
    557   ).toEqual(original.rows);
    558 });