app

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

retry-send.spec.ts (16267B)


      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/retry-send.ts';
      8 declare global {
      9   interface Window {
     10     hcp087: typeof Fixture;
     11     hcp087Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
     12     hcp087Pending: ReturnType<
     13       Awaited<ReturnType<typeof Fixture.makeFixture>>['run']
     14     >;
     15     hcp087Advance: () => void;
     16     hcp087Release: () => void;
     17     hcp087Waiting: 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/retry-send.ts', import.meta.url)
     85         ),
     86         name: 'hcp087',
     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.hcp087Fixture = await window.hcp087.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.hcp087Fixture?.close());
    137 });
    138 test('successful same-owner observations preserve recovered rumor and both original artifacts', async ({
    139   page
    140 }) => {
    141   const r = await page.evaluate(async () => {
    142     const f = window.hcp087Fixture,
    143       prepared = await f.prepare();
    144     f.capture();
    145     const before = f.countsValue(),
    146       result = await f.run();
    147     return {
    148       prepared,
    149       result,
    150       before,
    151       after: f.countsValue(),
    152       recovered: f.recovered(),
    153       row: await f.row()
    154     };
    155   });
    156   expect(r.prepared.status).toBe('existing');
    157   expect(r.result.status).toBe('completed');
    158   expect(r.recovered.rumor).toBe(true);
    159   expect(r.after.encrypts).toBe(r.before.encrypts);
    160   expect(r.after.signs).toBe(r.before.signs);
    161   expect(events.map((e) => e.wire)).toEqual([
    162     r.row.record.peerArtifact!.wire,
    163     r.row.record.self.wire
    164   ]);
    165 });
    166 test('actual reload retries only the remaining original artifact with no re-sign or rewrap', async ({
    167   page
    168 }) => {
    169   archiveResponse = 'unknown';
    170   const original = await page.evaluate(async () => {
    171     const f = window.hcp087Fixture;
    172     await f.prepare();
    173     f.capture();
    174     const result = await f.run();
    175     if (result.status !== 'needs_action')
    176       throw Error('missing real archive uncertainty');
    177     return (await f.row()).record;
    178   });
    179   await page.evaluate(() => window.hcp087Fixture.close());
    180   await page.reload();
    181   await load(page, false);
    182   response = 'accepted';
    183   archiveResponse = undefined;
    184   events = [];
    185   const r = await page.evaluate(async () => {
    186     const f = window.hcp087Fixture,
    187       baseline = f.countsValue(),
    188       prepared = await f.prepare();
    189     f.capture();
    190     const before = f.countsValue(),
    191       result = await f.run();
    192     return {
    193       prepared,
    194       result,
    195       baseline,
    196       before,
    197       after: f.countsValue(),
    198       row: (await f.row()).record
    199     };
    200   });
    201   expect(r.result.status).toBe('completed');
    202   // The existing fixture's genuine capability probe already exercised crypto.
    203   // Recovery and publication must add no encryption/signing to that baseline.
    204   expect(r.before.encrypts).toBe(r.baseline.encrypts);
    205   expect(r.before.signs).toBe(r.baseline.signs);
    206   expect(r.before.decrypts - r.baseline.decrypts).toBe(2);
    207   expect(r.after.encrypts).toBe(r.baseline.encrypts);
    208   expect(r.after.signs).toBe(r.baseline.signs);
    209   expect(r.row.self).toEqual(original.self);
    210   expect(r.row.peerArtifact).toEqual(original.peerArtifact);
    211   expect(events.map((e) => e.wire)).toEqual([original.self.wire]);
    212   expect(r.row.receipts).toHaveLength(5);
    213 });
    214 test('a second explicit action performs no duplicate accepted target work', async ({
    215   page
    216 }) => {
    217   const r = await page.evaluate(async () => {
    218     const f = window.hcp087Fixture;
    219     await f.prepare();
    220     f.capture();
    221     const first = await f.run();
    222     f.capture();
    223     const second = await f.run();
    224     return { first, second, row: (await f.row()).record };
    225   });
    226   expect(r.first.status).toBe('completed');
    227   expect(r.second.status).toBe('completed');
    228   expect(events).toHaveLength(2);
    229   expect(r.row.receipts).toHaveLength(2);
    230 });
    231 test('three real unknown attempts share one action and never schedule a fourth', async ({
    232   page
    233 }) => {
    234   response = 'unknown';
    235   const r = await page.evaluate(async () => {
    236     const f = window.hcp087Fixture;
    237     await f.prepare();
    238     f.capture();
    239     return { result: await f.run(), row: (await f.row()).record };
    240   });
    241   expect(r.result.status).toBe('needs_action');
    242   expect(events).toHaveLength(3);
    243   expect(new Set(events.map((e) => e.wire)).size).toBe(1);
    244   expect(r.row.receipts?.map((r) => r.attempt)).toEqual([1, 2, 3]);
    245   expect(new Set(r.row.receipts?.map((r) => r.actionId)).size).toBe(1);
    246 });
    247 test('authoritative auth refusal pauses without spinning or touching archive', async ({
    248   page
    249 }) => {
    250   response = 'refused';
    251   const r = await page.evaluate(async () => {
    252     const f = window.hcp087Fixture;
    253     await f.prepare();
    254     f.capture();
    255     return { result: await f.run(), row: (await f.row()).record };
    256   });
    257   expect(r.result.status).toBe('needs_action');
    258   expect(events).toHaveLength(1);
    259   expect(r.row.receipts?.[0].status).toBe('refused');
    260 });
    261 test('wrong review and reused completed action cannot silently start another effect', async ({
    262   page
    263 }) => {
    264   const r = await page.evaluate(async () => {
    265     const f = window.hcp087Fixture;
    266     await f.prepare();
    267     const wrong = f.capture('unreviewed');
    268     f.capture();
    269     const refused = await f.run('unreviewed');
    270     const first = await f.run();
    271     const second = await f.run();
    272     return { wrong, refused, first, second };
    273   });
    274   expect(r.wrong).toBe(false);
    275   expect(r.refused.status).toBe('invalid');
    276   expect(r.first.status).toBe('completed');
    277   expect(r.second.status).toBe('invalid');
    278   expect(events).toHaveLength(2);
    279 });
    280 test('changed stored revision prevents all retry effects', async ({ page }) => {
    281   const r = await page.evaluate(async () => {
    282     const f = window.hcp087Fixture;
    283     await f.prepare();
    284     f.capture();
    285     await f.write('revision');
    286     return f.run();
    287   });
    288   expect(r.status).toBe('needs_action');
    289   expect(events).toEqual([]);
    290 });
    291 test('Stop before execution fences every effect and preserves ciphertext', async ({
    292   page
    293 }) => {
    294   const r = await page.evaluate(async () => {
    295     const f = window.hcp087Fixture;
    296     await f.prepare();
    297     f.capture();
    298     const before = await f.row();
    299     f.stop();
    300     return { result: await f.run(), before, after: await f.row() };
    301   });
    302   expect(r.result.status).toBe('stopped');
    303   expect(r.after.wire).toBe(r.before.wire);
    304   expect(events).toEqual([]);
    305 });
    306 test('actual changed owner retires recovered private body before any EVENT', async ({
    307   page
    308 }) => {
    309   const r = await page.evaluate(async () => {
    310     const f = window.hcp087Fixture;
    311     await f.prepare();
    312     f.capture();
    313     f.mode('changed_key');
    314     return { result: await f.run(), recovered: f.recovered() };
    315   });
    316   expect(r.result.status).toBe('stopped');
    317   expect(r.recovered.rumor).toBe(false);
    318   expect(events).toEqual([]);
    319 });
    320 test('missing persisted ciphertext cannot become a successful retry', async ({
    321   page
    322 }) => {
    323   const r = await page.evaluate(async () => {
    324     const f = window.hcp087Fixture;
    325     await f.prepare();
    326     f.capture();
    327     await f.write('erase');
    328     return f.run();
    329   });
    330   expect(r.status).toBe('needs_action');
    331   expect(events).toEqual([]);
    332 });
    333 test('the shared 45 second network budget ends a real silent attempt without another EVENT', async ({
    334   page
    335 }) => {
    336   response = 'silent';
    337   await page.evaluate(async () => {
    338     const f = window.hcp087Fixture;
    339     await f.prepare();
    340     f.capture();
    341     const native = performance.now.bind(performance);
    342     let offset = 0;
    343     Object.defineProperty(performance, 'now', {
    344       configurable: true,
    345       value: () => native() + offset
    346     });
    347     window.hcp087Advance = () => {
    348       offset += 45001;
    349     };
    350     window.hcp087Pending = f.run();
    351   });
    352   await expect.poll(() => events.length).toBe(1);
    353   await page.evaluate(() => window.hcp087Advance());
    354   const r = await page.evaluate(() => window.hcp087Pending);
    355   expect(r.status).toBe('needs_action');
    356   expect(events).toHaveLength(1);
    357 });
    358 test('time spent awaiting the genuine provider observation is outside network budget', async ({
    359   page
    360 }) => {
    361   await page.evaluate(async () => {
    362     const f = window.hcp087Fixture;
    363     await f.prepare();
    364     f.capture();
    365     const native = performance.now.bind(performance);
    366     let offset = 0;
    367     Object.defineProperty(performance, 'now', {
    368       configurable: true,
    369       value: () => native() + offset
    370     });
    371     const provider = window.nostr as { getPublicKey(): Promise<string> };
    372     const original = provider.getPublicKey.bind(provider);
    373     let held = true;
    374     provider.getPublicKey = async () => {
    375       if (held) {
    376         held = false;
    377         window.hcp087Waiting = true;
    378         await new Promise<void>((resolve) => {
    379           window.hcp087Release = resolve;
    380         });
    381       }
    382       return original();
    383     };
    384     window.hcp087Advance = () => {
    385       offset += 60000;
    386     };
    387     window.hcp087Pending = f.run();
    388   });
    389   await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true);
    390   expect(events).toEqual([]);
    391   await page.evaluate(() => {
    392     window.hcp087Advance();
    393     window.hcp087Release();
    394   });
    395   const r = await page.evaluate(() => window.hcp087Pending);
    396   expect(r.status).toBe('completed');
    397   expect(events).toHaveLength(2);
    398 });
    399 test('a controlled genuine receipt successor accepted during key wait suppresses duplicate target publication', async ({
    400   page
    401 }) => {
    402   await page.evaluate(async () => {
    403     const f = window.hcp087Fixture;
    404     await f.prepare();
    405     f.capture();
    406     const provider = window.nostr as { getPublicKey(): Promise<string> },
    407       original = provider.getPublicKey.bind(provider);
    408     let calls = 0;
    409     provider.getPublicKey = async () => {
    410       calls++;
    411       if (calls === 2) {
    412         window.hcp087Waiting = true;
    413         await new Promise<void>((resolve) => {
    414           window.hcp087Release = resolve;
    415         });
    416       }
    417       return original();
    418     };
    419     window.hcp087Pending = f.run();
    420   });
    421   await expect.poll(() => page.evaluate(() => window.hcp087Waiting)).toBe(true);
    422   expect(events).toHaveLength(1);
    423   const successor = await page.evaluate(() =>
    424     window.hcp087Fixture.controlledArchiveSuccessor()
    425   );
    426   expect(successor.status).toBe('saved');
    427   await page.evaluate(() => window.hcp087Release());
    428   const result = await page.evaluate(() => window.hcp087Pending);
    429   expect(result.status).toBe('completed');
    430   expect(events).toHaveLength(1);
    431 });
    432 test('network time consumed by earlier real attempts reduces the remaining action allowance', async ({
    433   page
    434 }) => {
    435   response = 'silent';
    436   await page.evaluate(async () => {
    437     const f = window.hcp087Fixture;
    438     await f.prepare();
    439     f.capture();
    440     const native = performance.now.bind(performance);
    441     let offset = 0;
    442     Object.defineProperty(performance, 'now', {
    443       configurable: true,
    444       value: () => native() + offset
    445     });
    446     window.hcp087Advance = () => {
    447       offset += 30000;
    448     };
    449     window.hcp087Pending = f.run();
    450   });
    451   await expect.poll(() => events.length).toBe(1);
    452   await page.evaluate(() => window.hcp087Advance());
    453   pendingAcks[0].socket.send(
    454     JSON.stringify(['OK', pendingAcks[0].id, false, 'Timeout'])
    455   );
    456   await expect.poll(() => events.length).toBe(2);
    457   await page.evaluate(() => window.hcp087Advance());
    458   pendingAcks[1].socket.send(
    459     JSON.stringify(['OK', pendingAcks[1].id, false, 'Timeout'])
    460   );
    461   const r = await page.evaluate(async () => ({
    462     result: await window.hcp087Pending,
    463     row: (await window.hcp087Fixture.row()).record
    464   }));
    465   expect(r.result.status).toBe('needs_action');
    466   expect(events).toHaveLength(2);
    467   expect(events[1].wire).toBe(events[0].wire);
    468   expect(r.row.receipts?.map((f) => f.status)).toEqual([
    469     'unknown',
    470     'timed_out'
    471   ]);
    472 });
    473 test('a codec-valid success row inserted between verification and load cannot claim genuine completion', async ({
    474   page
    475 }) => {
    476   const r = await page.evaluate(async () => {
    477     const f = window.hcp087Fixture;
    478     await f.prepare();
    479     f.capture();
    480     const mutation = await f.injectUnacknowledgedSuccessBetweenReads(),
    481       proofBefore = f.proof(),
    482       result = await f.run(),
    483       injected = f.injected();
    484     f.clearFault();
    485     return {
    486       mutation,
    487       proofBefore,
    488       proofAfter: f.proof(),
    489       result,
    490       injected,
    491       row: await f.row()
    492     };
    493   });
    494   expect(r.injected).toBe(1);
    495   expect(r.row.wire).toBe(r.mutation.changedWire);
    496   expect(r.proofAfter).toEqual(r.proofBefore);
    497   expect(r.proofAfter?.revision).toBe(r.mutation.revision);
    498   expect(r.result.status).toBe('needs_action');
    499   expect(events).toEqual([]);
    500 });