app

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

resume-routing.spec.ts (11942B)


      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/resume-routing.ts';
      8 declare global {
      9   interface Window {
     10     hcp088: typeof Fixture;
     11     hcp088Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
     12   }
     13 }
     14 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     15   sockets: WebSocketServer,
     16   endpoint: string,
     17   bundle: string;
     18 let events: { origin: string; wire: string }[] = [];
     19 test.beforeAll(async () => {
     20   server = await createStaticHarness();
     21   sockets = new WebSocketServer({
     22     host: '127.0.0.1',
     23     port: 0,
     24     maxPayload: 65536
     25   });
     26   await once(sockets, 'listening');
     27   const address = sockets.address();
     28   if (!address || typeof address === 'string')
     29     throw Error('loopback unavailable');
     30   endpoint = 'ws://127.0.0.1:' + address.port;
     31   sockets.on('connection', (socket, request) =>
     32     socket.on('message', (bytes) => {
     33       const raw = Buffer.isBuffer(bytes)
     34           ? bytes
     35           : Array.isArray(bytes)
     36             ? Buffer.concat(bytes)
     37             : Buffer.from(bytes),
     38         frame = JSON.parse(raw.toString()) as unknown[];
     39       if (frame[0] !== 'EVENT') return;
     40       const event = frame[1] as { id: string };
     41       events.push({
     42         origin: new URL(request.url!, 'http://localhost').searchParams.get(
     43           'origin'
     44         )!,
     45         wire: JSON.stringify(event)
     46       });
     47       socket.send(JSON.stringify(['OK', event.id, true, '']));
     48     })
     49   );
     50   const result = await build({
     51     configFile: false,
     52     logLevel: 'silent',
     53     build: {
     54       write: false,
     55       minify: false,
     56       lib: {
     57         entry: fileURLToPath(
     58           new URL('./harness/resume-routing.ts', import.meta.url)
     59         ),
     60         name: 'hcp088',
     61         formats: ['iife']
     62       }
     63     }
     64   });
     65   const output = Array.isArray(result) ? result[0] : result;
     66   if (!('output' in output)) throw Error('bundle missing');
     67   const chunks = output.output.filter((x) => x.type === 'chunk');
     68   expect(chunks).toHaveLength(1);
     69   bundle = chunks[0].code;
     70 });
     71 test.afterAll(async () => {
     72   for (const socket of sockets.clients) socket.terminate();
     73   await new Promise<void>((r) => sockets.close(() => r()));
     74   await server.close();
     75 });
     76 test.beforeEach(async ({ page }) => {
     77   events = [];
     78   await page.addInitScript(
     79     ({ endpoint }) => {
     80       const Native = window.WebSocket;
     81       window.WebSocket = class extends Native {
     82         constructor(url: string | URL, protocols?: string | string[]) {
     83           const origin = new URL(String(url)).origin;
     84           if (
     85             ![
     86               'wss://peer.example.org',
     87               'wss://archive.example.org',
     88               'wss://new-peer.example.org'
     89             ].includes(origin)
     90           )
     91             throw Error('unapproved destination');
     92           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
     93         }
     94       };
     95     },
     96     { endpoint }
     97   );
     98   await page.goto(server.url + '/search');
     99   await page.addScriptTag({ content: bundle });
    100   await page.evaluate(async () => {
    101     window.hcp088Fixture = await window.hcp088.makeFixture();
    102   });
    103 });
    104 test.afterEach(async ({ page }) => {
    105   if (!page.isClosed())
    106     await page.evaluate(() => window.hcp088Fixture?.close());
    107 });
    108 test('removed inbox is previewed exactly and unreviewed resumption has no automatic replay', async ({
    109   page
    110 }) => {
    111   const r = await page.evaluate(async () => {
    112     const f = window.hcp088Fixture,
    113       before = await f.row();
    114     return {
    115       captured: f.capture(),
    116       snapshot: f.snapshot(),
    117       result: await f.approve('unreviewed'),
    118       before,
    119       after: await f.row(),
    120       retry: await f.retry(true)
    121     };
    122   });
    123   expect(r.captured).toBe(true);
    124   expect(r.snapshot?.changes.peer.removed).toEqual(['wss://peer.example.org']);
    125   expect(r.snapshot?.changes.peer.added).toEqual([
    126     'wss://new-peer.example.org'
    127   ]);
    128   expect(r.result.status).toBe('invalid');
    129   expect(r.after).toEqual(r.before);
    130   expect(r.retry.status).toBe('invalid');
    131   expect(events).toEqual([]);
    132 });
    133 test('same original ciphertext reaches only the explicitly approved newly advertised destination and old attempts remain', async ({
    134   page
    135 }) => {
    136   const r = await page.evaluate(async () => {
    137     const f = window.hcp088Fixture;
    138     await f.retry(true);
    139     const before = await f.row(),
    140       counts = f.counts();
    141     f.capture();
    142     const updated = await f.approve(),
    143       old = await f.retry(true),
    144       result = await f.retry();
    145     return {
    146       before,
    147       after: await f.row(),
    148       counts,
    149       afterCounts: f.counts(),
    150       updated,
    151       old,
    152       result
    153     };
    154   });
    155   expect(r.updated.status).toBe('updated');
    156   expect(r.old.status).toBe('invalid');
    157   expect(r.result.status).toBe('completed');
    158   expect(r.after?.record.self).toEqual(r.before?.record.self);
    159   expect(r.after?.record.peerArtifact).toEqual(r.before?.record.peerArtifact);
    160   expect(r.after?.record.receipts?.slice(0, 2)).toEqual(
    161     r.before?.record.receipts
    162   );
    163   expect(r.after?.record.receipts).toHaveLength(3);
    164   expect(r.afterCounts.encrypts).toBe(r.counts.encrypts);
    165   expect(r.afterCounts.signs).toBe(r.counts.signs);
    166   expect(events.map((e) => e.origin)).toEqual([
    167     'wss://peer.example.org',
    168     'wss://archive.example.org',
    169     'wss://new-peer.example.org'
    170   ]);
    171   expect(events[2].wire).toBe(events[0].wire);
    172 });
    173 test('new unapproved advertised URL has no route capability or network access', async ({
    174   page
    175 }) => {
    176   const r = await page.evaluate(async () => {
    177     const f = window.hcp088Fixture,
    178       before = await f.row();
    179     return {
    180       captured: f.capture('wss://unapproved.example.org'),
    181       approved: await f.approve(),
    182       before,
    183       after: await f.row()
    184     };
    185   });
    186   expect(r.captured).toBe(false);
    187   expect(r.approved.status).toBe('invalid');
    188   expect(r.after).toEqual(r.before);
    189   expect(events).toEqual([]);
    190 });
    191 test('peer switch requires a new message and cannot retarget existing ciphertext', async ({
    192   page
    193 }) => {
    194   const r = await page.evaluate(async () => {
    195     const f = window.hcp088Fixture,
    196       before = await f.row();
    197     return {
    198       captured: f.capture(
    199         'wss://new-peer.example.org',
    200         'wss://archive.example.org',
    201         true
    202       ),
    203       approved: await f.approve(),
    204       before,
    205       after: await f.row()
    206     };
    207   });
    208   expect(r.captured).toBe(false);
    209   expect(r.approved.status).toBe('invalid');
    210   expect(r.after).toEqual(r.before);
    211   expect(events).toEqual([]);
    212 });
    213 test('sender archive changes use its own advertised set while preserving the peer artifact', async ({
    214   page
    215 }) => {
    216   const r = await page.evaluate(async () => {
    217     const f = window.hcp088Fixture,
    218       before = await f.row();
    219     f.capture('wss://peer.example.org', 'wss://new-peer.example.org');
    220     const snapshot = f.snapshot(),
    221       updated = await f.approve(),
    222       result = await f.retry();
    223     return { before, after: await f.row(), snapshot, updated, result };
    224   });
    225   expect(r.snapshot?.changes.archive.removed).toEqual([
    226     'wss://archive.example.org'
    227   ]);
    228   expect(r.updated.status).toBe('updated');
    229   expect(r.result.status).toBe('completed');
    230   expect(events.map((e) => e.origin)).toEqual([
    231     'wss://peer.example.org',
    232     'wss://new-peer.example.org'
    233   ]);
    234   expect(events[1].wire).toBe(r.before?.record.self.wire);
    235   expect(r.after?.record.peerArtifact).toEqual(r.before?.record.peerArtifact);
    236 });
    237 test('incomplete current discovery cannot supply route consent', async ({
    238   page
    239 }) => {
    240   const r = await page.evaluate(() => {
    241     const f = window.hcp088Fixture;
    242     return f.capture(
    243       'wss://new-peer.example.org',
    244       'wss://archive.example.org',
    245       false,
    246       false
    247     );
    248   });
    249   expect(r).toBe(false);
    250   expect(events).toEqual([]);
    251 });
    252 test('stale discovery after review blocks destination update', async ({
    253   page
    254 }) => {
    255   const r = await page.evaluate(async () => {
    256     const f = window.hcp088Fixture,
    257       before = await f.row();
    258     f.capture();
    259     f.stale();
    260     return { result: await f.approve(), before, after: await f.row() };
    261   });
    262   expect(r.result.status).toBe('stopped');
    263   expect(r.after).toEqual(r.before);
    264   expect(events).toEqual([]);
    265 });
    266 test('competing whole-wire successor cannot renew route-updated custody', async ({
    267   page
    268 }) => {
    269   const r = await page.evaluate(async () => {
    270     const f = window.hcp088Fixture;
    271     f.capture();
    272     await f.write('revision');
    273     const before = await f.row();
    274     return {
    275       result: await f.approve(),
    276       before,
    277       after: await f.row(),
    278       retry: await f.retry()
    279     };
    280   });
    281   expect(r.result.status).toBe('conflict');
    282   expect(r.after).toEqual(r.before);
    283   expect(r.retry.status).toBe('invalid');
    284   expect(events).toEqual([]);
    285 });
    286 test('fresh changed owner refuses reviewed destination update without encryption or signing', async ({
    287   page
    288 }) => {
    289   const r = await page.evaluate(async () => {
    290     const f = window.hcp088Fixture;
    291     f.capture();
    292     const before = await f.row(),
    293       counts = f.counts();
    294     f.mode('changed_key');
    295     return {
    296       result: await f.approve(),
    297       before,
    298       after: await f.row(),
    299       counts,
    300       afterCounts: f.counts()
    301     };
    302   });
    303   expect(r.result.status).toBe('stopped');
    304   expect(r.after).toEqual(r.before);
    305   expect(r.afterCounts.encrypts).toBe(r.counts.encrypts);
    306   expect(r.afterCounts.signs).toBe(r.counts.signs);
    307   expect(events).toEqual([]);
    308 });
    309 test('actual IDB abort and post-put readback loss do not acknowledge route permission', async ({
    310   page
    311 }) => {
    312   const r = await page.evaluate(async () => {
    313     const f = window.hcp088Fixture;
    314     f.capture();
    315     const before = await f.row();
    316     f.fault('abort');
    317     const aborted = await f.approve(),
    318       afterAbort = await f.row();
    319     f.capture();
    320     f.fault('readback');
    321     const unknown = await f.approve(),
    322       retry = await f.retry();
    323     return { before, afterAbort, aborted, unknown, retry };
    324   });
    325   expect(r.aborted.status).toBe('aborted');
    326   expect(r.afterAbort).toEqual(r.before);
    327   expect(r.unknown.status).toBe('unknown_completion');
    328   expect(r.retry.status).toBe('invalid');
    329   expect(events).toEqual([]);
    330 });
    331 
    332 test('unsupported current inbox resolution also fences previously genuine old-route replay', async ({
    333   page
    334 }) => {
    335   const r = await page.evaluate(async () => {
    336     const f = window.hcp088Fixture,
    337       before = await f.row();
    338     const captured = f.capture('wss://unapproved.example.org');
    339     return {
    340       captured,
    341       before,
    342       result: await f.retry(true),
    343       after: await f.row()
    344     };
    345   });
    346   expect(r.captured).toBe(false);
    347   expect(r.result.status).toBe('invalid');
    348   expect(r.after).toEqual(r.before);
    349   expect(events).toEqual([]);
    350 });
    351 
    352 async function assertAlreadyHeldFenced(
    353   page: import('@playwright/test').Page,
    354   destination: string,
    355   reviewReady: boolean
    356 ) {
    357   const r = await page.evaluate(async (destination) => {
    358     const f = window.hcp088Fixture,
    359       held = f.captureHeld(),
    360       before = await f.row();
    361     const reviewed = f.capture(destination);
    362     return {
    363       held,
    364       reviewed,
    365       before,
    366       result: await f.runHeld(),
    367       after: await f.row()
    368     };
    369   }, destination);
    370   expect(r.held).toBe(true);
    371   expect(r.reviewed).toBe(reviewReady);
    372   expect(r.result.status).toBe('needs_action');
    373   expect(r.after).toEqual(r.before);
    374   expect(events).toEqual([]);
    375 }
    376 test('already captured genuine retry cannot publish while supported destination review is pending', async ({
    377   page
    378 }) => {
    379   await assertAlreadyHeldFenced(page, 'wss://new-peer.example.org', true);
    380 });
    381 test('already captured genuine retry cannot replay after current inbox becomes unsupported', async ({
    382   page
    383 }) => {
    384   await assertAlreadyHeldFenced(page, 'wss://unapproved.example.org', false);
    385 });