app

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

stop-send.spec.ts (17237B)


      1 import { test, expect } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { once } from 'node:events';
      5 import { WebSocketServer } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/stop-send.ts';
      8 declare global {
      9   interface Window {
     10     hcp089: typeof Fixture;
     11     hcp089Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
     12     hcp089Pending: ReturnType<
     13       Awaited<ReturnType<typeof Fixture.makeFixture>>['run']
     14     >;
     15     hcp089Advance: () => void;
     16     hcp089Release: () => void;
     17     hcp089Waiting: boolean;
     18   }
     19 }
     20 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     21   sockets: WebSocketServer,
     22   endpoint: string,
     23   bundle: string;
     24 let events: { origin: string; wire: string }[] = [],
     25   response: 'accepted' | 'refused' | 'unknown' | 'silent' = 'accepted';
     26 let archiveResponse: 'accepted' | 'refused' | 'unknown' | 'silent' | undefined;
     27 let pendingAcks: { socket: import('ws').WebSocket; id: string }[] = [];
     28 test.beforeAll(async () => {
     29   server = await createStaticHarness();
     30   sockets = new WebSocketServer({
     31     host: '127.0.0.1',
     32     port: 0,
     33     maxPayload: 65536
     34   });
     35   await once(sockets, 'listening');
     36   const address = sockets.address();
     37   if (!address || typeof address === 'string')
     38     throw Error('loopback unavailable');
     39   endpoint = 'ws://127.0.0.1:' + address.port;
     40   sockets.on('connection', (socket, request) =>
     41     socket.on('message', (bytes) => {
     42       const raw = Buffer.isBuffer(bytes)
     43           ? bytes
     44           : Array.isArray(bytes)
     45             ? Buffer.concat(bytes)
     46             : Buffer.from(bytes),
     47         frame = JSON.parse(raw.toString()) as unknown[];
     48       if (frame[0] !== 'EVENT') return;
     49       const event = frame[1] as { id: string };
     50       pendingAcks.push({ socket, id: event.id });
     51       events.push({
     52         origin: new URL(request.url!, 'http://localhost').searchParams.get(
     53           'origin'
     54         )!,
     55         wire: JSON.stringify(event)
     56       });
     57       const outcome =
     58         events.at(-1)!.origin === 'wss://archive.example.org'
     59           ? (archiveResponse ?? response)
     60           : response;
     61       if (outcome !== 'silent')
     62         socket.send(
     63           JSON.stringify([
     64             'OK',
     65             event.id,
     66             outcome === 'accepted',
     67             outcome === 'unknown'
     68               ? 'Timeout'
     69               : outcome === 'refused'
     70                 ? 'auth-required: fixture refusal'
     71                 : ''
     72           ])
     73         );
     74     })
     75   );
     76   const result = await build({
     77     configFile: false,
     78     logLevel: 'silent',
     79     build: {
     80       write: false,
     81       minify: false,
     82       lib: {
     83         entry: fileURLToPath(
     84           new URL('./harness/stop-send.ts', import.meta.url)
     85         ),
     86         name: 'hcp089',
     87         formats: ['iife']
     88       }
     89     }
     90   });
     91   const output = Array.isArray(result) ? result[0] : result;
     92   if (!('output' in output)) throw Error('bundle unavailable');
     93   const chunks = output.output.filter((x) => x.type === 'chunk');
     94   expect(chunks).toHaveLength(1);
     95   bundle = chunks[0].code;
     96 });
     97 test.afterAll(async () => {
     98   for (const socket of sockets.clients) socket.terminate();
     99   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    100   await server.close();
    101 });
    102 async function load(page: import('@playwright/test').Page, initialise = true) {
    103   await page.goto(server.url + '/search');
    104   await page.addScriptTag({ content: bundle });
    105   await page.evaluate(async (initialise) => {
    106     window.hcp089Fixture = await window.hcp089.makeFixture(initialise);
    107   }, initialise);
    108 }
    109 test.beforeEach(async ({ page }) => {
    110   events = [];
    111   response = 'accepted';
    112   archiveResponse = undefined;
    113   pendingAcks = [];
    114   await page.addInitScript(
    115     ({ endpoint }) => {
    116       const Native = window.WebSocket;
    117       window.WebSocket = class extends Native {
    118         constructor(url: string | URL, protocols?: string | string[]) {
    119           const origin = new URL(String(url)).origin;
    120           if (
    121             !['wss://peer.example.org', 'wss://archive.example.org'].includes(
    122               origin
    123             )
    124           )
    125             throw Error('unapproved destination');
    126           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    127         }
    128       };
    129     },
    130     { endpoint }
    131   );
    132   await load(page);
    133 });
    134 test.afterEach(async ({ page }) => {
    135   if (!page.isClosed())
    136     await page.evaluate(() => window.hcp089Fixture?.close());
    137 });
    138 test('Stop after an actual silent EVENT preserves original uncertain target receipt', async ({
    139   page
    140 }) => {
    141   response = 'silent';
    142   const before = await page.evaluate(async () => {
    143     const f = window.hcp089Fixture;
    144     await f.prepare();
    145     f.capture();
    146     const before = await f.row();
    147     window.hcp089Pending = f.run();
    148     return before;
    149   });
    150   await expect.poll(() => events.length).toBe(1);
    151   const r = await page.evaluate(async () => {
    152     const f = window.hcp089Fixture;
    153     f.stop();
    154     return {
    155       result: await window.hcp089Pending,
    156       row: await f.row(),
    157       snapshot: f.snapshot()
    158     };
    159   });
    160   expect(r.result.status).toBe('stopped');
    161   expect(events).toHaveLength(1);
    162   expect(r.row.record.self).toEqual(before.record.self);
    163   expect(r.row.record.peerArtifact).toEqual(before.record.peerArtifact);
    164   expect(r.row.record.receipts).toHaveLength(1);
    165   expect(r.row.record.receipts![0]).toMatchObject({
    166     role: 'peer',
    167     origin: 'wss://peer.example.org',
    168     eventId: before.record.peerArtifact!.eventId,
    169     status: 'stopped',
    170     attempt: 1
    171   });
    172 });
    173 test('disconnect during actual publish retains original-owner uncertainty without archive or auto resume', async ({
    174   page
    175 }) => {
    176   response = 'silent';
    177   const before = await page.evaluate(async () => {
    178     const f = window.hcp089Fixture;
    179     await f.prepare();
    180     f.capture();
    181     const before = await f.row();
    182     window.hcp089Pending = f.run();
    183     return before;
    184   });
    185   await expect.poll(() => events.length).toBe(1);
    186   const r = await page.evaluate(async () => {
    187     const f = window.hcp089Fixture;
    188     f.disconnect();
    189     const result = await window.hcp089Pending;
    190     return {
    191       result,
    192       row: await f.row(),
    193       recapture: f.capture(),
    194       rerun: await f.run()
    195     };
    196   });
    197   expect(r.result.status).toBe('stopped');
    198   expect(r.recapture).toBe(false);
    199   expect(r.rerun.status).toBe('invalid');
    200   expect(events).toHaveLength(1);
    201   expect(r.row.record.owner).toBe(before.record.owner);
    202   expect(r.row.record.self).toEqual(before.record.self);
    203   expect(r.row.record.peerArtifact).toEqual(before.record.peerArtifact);
    204   expect(r.row.record.receipts).toHaveLength(1);
    205   expect(r.row.record.receipts![0].status).toBe('stopped');
    206 });
    207 test('Stop before execution preserves exact bytes with no attempted fact or EVENT', async ({
    208   page
    209 }) => {
    210   const r = await page.evaluate(async () => {
    211     const f = window.hcp089Fixture;
    212     await f.prepare();
    213     f.capture();
    214     const before = await f.row();
    215     f.stop();
    216     return { before, after: await f.row(), result: await f.run() };
    217   });
    218   expect(r.result.status).toBe('stopped');
    219   expect(r.after.wire).toBe(r.before.wire);
    220   expect(events).toEqual([]);
    221 });
    222 test('late ACK after Stop cannot erase uncertainty or publish sender archive', async ({
    223   page
    224 }) => {
    225   response = 'silent';
    226   await page.evaluate(async () => {
    227     const f = window.hcp089Fixture;
    228     await f.prepare();
    229     f.capture();
    230     window.hcp089Pending = f.run();
    231   });
    232   await expect.poll(() => events.length).toBe(1);
    233   const r = await page.evaluate(async () => {
    234     const f = window.hcp089Fixture;
    235     f.stop();
    236     await window.hcp089Pending;
    237     return f.row();
    238   });
    239   for (const ack of pendingAcks)
    240     if (ack.socket.readyState === 1)
    241       ack.socket.send(JSON.stringify(['OK', ack.id, true, '']));
    242   const after = await page.evaluate(() => window.hcp089Fixture.row());
    243   expect(r.record.receipts).toHaveLength(1);
    244   expect(r.record.receipts![0].status).toBe('stopped');
    245   expect(after.wire).toBe(r.wire);
    246   expect(events).toHaveLength(1);
    247 });
    248 test('real accepted SDK result crossing Stop and logout during receipt read preserves acceptance', async ({
    249   page
    250 }) => {
    251   await page.evaluate(async () => {
    252     const f = window.hcp089Fixture;
    253     await f.prepare();
    254     f.capture();
    255     let acknowledged = false,
    256       stopped = false;
    257     // Observe the actual SDK socket's OK before the receipt read. The native
    258     // transport still receives and verifies the same frame through Applesauce.
    259     const cursor = Reflect.get<IDBIndex, 'openCursor'>(
    260       IDBIndex.prototype,
    261       'openCursor'
    262     );
    263     const Native = window.WebSocket;
    264     window.WebSocket = class extends Native {
    265       constructor(url: string | URL, protocols?: string | string[]) {
    266         super(url, protocols);
    267         this.addEventListener('message', (event) => {
    268           const frame = JSON.parse(String(event.data)) as unknown[];
    269           if (frame[0] === 'OK' && frame[2] === true) acknowledged = true;
    270         });
    271       }
    272     };
    273     IDBIndex.prototype.openCursor = function (
    274       ...args: Parameters<IDBIndex['openCursor']>
    275     ) {
    276       if (
    277         acknowledged &&
    278         !stopped &&
    279         this.objectStore.name === 'private_sends'
    280       ) {
    281         stopped = true;
    282         f.stop();
    283         f.disconnect();
    284       }
    285       return cursor.apply(this, args);
    286     };
    287     try {
    288       window.hcp089Pending = f.run();
    289       await window.hcp089Pending;
    290     } finally {
    291       IDBIndex.prototype.openCursor = cursor;
    292       window.WebSocket = Native;
    293     }
    294     window.hcp089Waiting = stopped;
    295   });
    296   const r = await page.evaluate(async () => ({
    297     stopped: window.hcp089Waiting,
    298     result: await window.hcp089Pending,
    299     row: await window.hcp089Fixture.row(),
    300     status: await window.hcp089Fixture.sendStatus()
    301   }));
    302   expect(r.stopped).toBe(true);
    303   expect(r.result.status).toBe('stopped');
    304   expect(events).toHaveLength(1);
    305   expect(r.row.record.receipts).toHaveLength(1);
    306   expect(r.row.record.receipts![0].status).toBe('accepted');
    307   expect(r.status!.recipient.acceptedTargets).toEqual([
    308     'wss://peer.example.org'
    309   ]);
    310   expect(r.status!.archive.state).toBe('pending');
    311 });
    312 test('actual original-owner settlement survives logout, is idempotent and rejects a cloned result', async ({
    313   page
    314 }) => {
    315   const r = await page.evaluate(async () => {
    316     const f = window.hcp089Fixture;
    317     await f.prepare();
    318     const before = await f.row();
    319     const result = await f.publishObserved();
    320     f.disconnect();
    321     const counts = f.countsValue();
    322     const clone = await f.settleObserved(true),
    323       first = await f.settleObserved(),
    324       after = await f.row(),
    325       again = await f.settleObserved(),
    326       final = await f.row();
    327     return {
    328       result,
    329       before,
    330       clone,
    331       first: first.status,
    332       again: again.status,
    333       after,
    334       final,
    335       counts,
    336       countsAfter: f.countsValue()
    337     };
    338   });
    339   expect(r.result.status).toBe('accepted');
    340   expect(r.clone.status).toBe('invalid');
    341   expect(r.first).toBe('saved');
    342   expect(r.again).toBe('existing');
    343   expect(r.after.wire).toBe(r.final.wire);
    344   expect(r.after.record.receipts).toHaveLength(1);
    345   expect(r.after.record.owner).toBe(r.before.record.owner);
    346   expect(r.after.record.self).toEqual(r.before.record.self);
    347   expect(r.after.record.peerArtifact).toEqual(r.before.record.peerArtifact);
    348   expect(r.countsAfter).toEqual(r.counts);
    349   expect(events).toHaveLength(1);
    350 });
    351 test('late actual result cannot attach to a different immutable operation scope', async ({
    352   page
    353 }) => {
    354   const r = await page.evaluate(async () => {
    355     const f = window.hcp089Fixture;
    356     await f.prepare();
    357     await f.publishObserved();
    358     const wire = await f.replaceImmutableScope();
    359     return { wire, result: await f.settleObserved(), after: await f.row() };
    360   });
    361   expect(r.result.status).toBe('conflict');
    362   expect(r.after.wire).toBe(r.wire);
    363   expect(r.after.record.receipts).toBeUndefined();
    364   expect(events).toHaveLength(1);
    365 });
    366 test('real settlement IDB abort is not durable success and explicit metadata retry preserves the original result', async ({
    367   page
    368 }) => {
    369   const r = await page.evaluate(async () => {
    370     const f = window.hcp089Fixture;
    371     await f.prepare();
    372     await f.publishObserved();
    373     const before = await f.row();
    374     f.disconnect();
    375     f.faultSettlement('abort');
    376     const failed = await f.settleObserved();
    377     f.clearFault();
    378     const after = await f.row();
    379     const retried = await f.settleObserved();
    380     return {
    381       before,
    382       after,
    383       failed,
    384       retried: retried.status,
    385       row: await f.row()
    386     };
    387   });
    388   expect(r.failed.status).toBe('aborted');
    389   expect(r.after.wire).toBe(r.before.wire);
    390   expect(r.retried).toBe('saved');
    391   expect(r.row.record.receipts).toHaveLength(1);
    392   expect(events).toHaveLength(1);
    393 });
    394 test('real post-put settlement readback failure remains unknown despite committed bytes', async ({
    395   page
    396 }) => {
    397   const r = await page.evaluate(async () => {
    398     const f = window.hcp089Fixture;
    399     await f.prepare();
    400     await f.publishObserved();
    401     f.disconnect();
    402     f.faultSettlement('readback');
    403     const failed = await f.settleObserved();
    404     f.clearFault();
    405     const retried = await f.settleObserved();
    406     return { failed, retried: retried.status, row: await f.row() };
    407   });
    408   expect(r.failed.status).toBe('unknown_completion');
    409   expect(r.retried).toBe('existing');
    410   expect(r.row.record.receipts).toHaveLength(1);
    411   expect(events).toHaveLength(1);
    412 });
    413 test('stopped projection retains uncertain target and honest recipient/archive language', async ({
    414   page
    415 }) => {
    416   response = 'silent';
    417   await page.evaluate(async () => {
    418     const f = window.hcp089Fixture;
    419     await f.prepare();
    420     f.capture();
    421     window.hcp089Pending = f.run();
    422   });
    423   await expect.poll(() => events.length).toBe(1);
    424   const r = await page.evaluate(async () => {
    425     const f = window.hcp089Fixture;
    426     f.stop();
    427     await window.hcp089Pending;
    428     return { snapshot: f.snapshot(), status: await f.sendStatus() };
    429   });
    430   expect(r.snapshot!.labels).toContain('Stopped');
    431   expect(r.status!.recipient.uncertainTargets).toEqual([
    432     'wss://peer.example.org'
    433   ]);
    434   expect(r.status!.labels).toContain('Recipient delivery unknown');
    435   expect(r.status!.labels).toContain('Sender archive pending');
    436   expect([...r.snapshot!.labels, ...r.status!.labels].join(' ')).not.toMatch(
    437     /Order accepted|Seen|Read|Delivered to person|permanent retention|guaranteed notification/
    438   );
    439 });
    440 test('reload remembers ciphertext but only explicit matching-owner Resume publishes original artifacts', async ({
    441   page
    442 }) => {
    443   response = 'silent';
    444   const before = await page.evaluate(async () => {
    445     const f = window.hcp089Fixture;
    446     await f.prepare();
    447     f.capture();
    448     const row = await f.row();
    449     window.hcp089Pending = f.run();
    450     return row;
    451   });
    452   await expect.poll(() => events.length).toBe(1);
    453   const stopped = await page.evaluate(async () => {
    454     const f = window.hcp089Fixture;
    455     f.stop();
    456     await window.hcp089Pending;
    457     return f.row();
    458   });
    459   await page.reload();
    460   await load(page, false);
    461   expect(events).toHaveLength(1);
    462   const captured = await page.evaluate(async () => {
    463     const f = window.hcp089Fixture;
    464     const prepared = await f.prepare();
    465     return { prepared, captured: f.capture(), row: await f.row() };
    466   });
    467   expect(captured.prepared.status).toBe('existing');
    468   expect(captured.captured).toBe(true);
    469   expect(events).toHaveLength(1);
    470   expect(captured.row.wire).toBe(stopped.wire);
    471   response = 'accepted';
    472   const resumed = await page.evaluate(async () => ({
    473     result: await window.hcp089Fixture.run(),
    474     row: await window.hcp089Fixture.row()
    475   }));
    476   expect(resumed.result.status).toBe('completed');
    477   expect(events).toHaveLength(3);
    478   expect(events.slice(1).map((e) => e.wire)).toEqual([
    479     before.record.peerArtifact!.wire,
    480     before.record.self.wire
    481   ]);
    482   expect(resumed.row.record.receipts).toHaveLength(3);
    483   expect(resumed.row.record.receipts![0]).toEqual(stopped.record.receipts![0]);
    484 });
    485 test('Stop in sender archive preserves actual prior recipient acceptance and partial archive uncertainty', async ({
    486   page
    487 }) => {
    488   archiveResponse = 'silent';
    489   await page.evaluate(async () => {
    490     const f = window.hcp089Fixture;
    491     await f.prepare();
    492     f.capture();
    493     window.hcp089Pending = f.run();
    494   });
    495   await expect.poll(() => events.length).toBe(2);
    496   const r = await page.evaluate(async () => {
    497     const f = window.hcp089Fixture;
    498     f.stop();
    499     const result = await window.hcp089Pending;
    500     return { result, row: await f.row(), status: await f.sendStatus() };
    501   });
    502   expect(r.result.status).toBe('stopped');
    503   expect(events).toHaveLength(2);
    504   expect(r.row.record.receipts!.map((f) => [f.role, f.status])).toEqual([
    505     ['peer', 'accepted'],
    506     ['self_archive', 'stopped']
    507   ]);
    508   expect(r.status!.recipient.state).toBe('accepted_by_inbox_relay');
    509   expect(r.status!.archive.state).toBe('pending');
    510   expect(r.status!.partial).toBe(true);
    511   expect(r.status!.labels).toContain('Accepted by recipient inbox relay');
    512   expect(r.status!.labels).toContain('Partial delivery');
    513   expect(r.status!.labels).toContain('Sender archive pending');
    514 });