app

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

history-cursor.spec.ts (9417B)


      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, type WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/history-cursor.ts';
      8 declare global {
      9   interface Window {
     10     hcp096: typeof Fixture;
     11     hcp096Fixture: 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 holdLatest = false,
     19   finiteOnly = false;
     20 let requests: unknown[][] = [],
     21   closes: unknown[][] = [],
     22   live = new Map<WebSocket, string>(),
     23   frames: Record<string, unknown>[] = [];
     24 test.beforeAll(async () => {
     25   server = await createStaticHarness();
     26   sockets = new WebSocketServer({
     27     host: '127.0.0.1',
     28     port: 0,
     29     maxPayload: 65536
     30   });
     31   await once(sockets, 'listening');
     32   const address = sockets.address();
     33   if (!address || typeof address === 'string')
     34     throw Error('loopback unavailable');
     35   endpoint = 'ws://127.0.0.1:' + address.port;
     36   sockets.on('connection', (socket) =>
     37     socket.on('message', (bytes) => {
     38       const raw = Buffer.isBuffer(bytes)
     39           ? bytes
     40           : Array.isArray(bytes)
     41             ? Buffer.concat(bytes)
     42             : Buffer.from(bytes),
     43         frame = JSON.parse(raw.toString()) as unknown[];
     44       if (frame[0] === 'CLOSE') {
     45         closes.push(frame);
     46         return;
     47       }
     48       if (frame[0] !== 'REQ') return;
     49       requests.push(frame);
     50       const filter = frame[2] as { limit: number; since?: number };
     51       if (filter.limit === 0) {
     52         live.set(socket, String(frame[1]));
     53         for (const event of (finiteOnly ? [] : frames).filter(
     54           (e) =>
     55             filter.since === undefined || Number(e.created_at) >= filter.since
     56         ))
     57           socket.send(JSON.stringify(['EVENT', frame[1], event]));
     58         socket.send(JSON.stringify(['EOSE', frame[1]]));
     59       } else {
     60         for (const event of frames.filter(
     61           (e) =>
     62             filter.since === undefined || Number(e.created_at) >= filter.since
     63         ))
     64           socket.send(JSON.stringify(['EVENT', frame[1], event]));
     65         if (!holdLatest) socket.send(JSON.stringify(['EOSE', frame[1]]));
     66       }
     67     })
     68   );
     69   const result = await build({
     70     configFile: false,
     71     logLevel: 'silent',
     72     build: {
     73       write: false,
     74       minify: false,
     75       lib: {
     76         entry: fileURLToPath(
     77           new URL('./harness/history-cursor.ts', import.meta.url)
     78         ),
     79         name: 'hcp096',
     80         formats: ['iife']
     81       }
     82     }
     83   });
     84   const output = Array.isArray(result) ? result[0] : result;
     85   if (!('output' in output)) throw Error('bundle unavailable');
     86   const chunks = output.output.filter((x) => x.type === 'chunk');
     87   expect(chunks).toHaveLength(1);
     88   bundle = chunks[0].code;
     89 });
     90 test.afterAll(async () => {
     91   for (const socket of sockets.clients) socket.terminate();
     92   await new Promise<void>((resolve) => sockets.close(() => resolve()));
     93   await server.close();
     94 });
     95 test.beforeEach(async ({ page }, testInfo) => {
     96   holdLatest = false;
     97   finiteOnly = false;
     98   requests = [];
     99   closes = [];
    100   frames = [];
    101   live = new Map();
    102   await page.addInitScript(
    103     ({ endpoint }) => {
    104       const Native = window.WebSocket;
    105       window.WebSocket = class extends Native {
    106         constructor(url: string | URL, protocols?: string | string[]) {
    107           if (new URL(String(url)).origin !== 'wss://archive.example.org')
    108             throw Error('unapproved receive destination');
    109           super(endpoint, protocols);
    110         }
    111       };
    112     },
    113     { endpoint }
    114   );
    115   await page.goto(server.url + '/search');
    116   await page.addScriptTag({ content: bundle });
    117   const age = testInfo.title.includes('much older delayed') ? 30 * 86400 : 0;
    118   await page.evaluate(async (age) => {
    119     window.hcp096Fixture = await window.hcp096.makeFixture(undefined, age);
    120   }, age);
    121 });
    122 test.afterEach(async ({ page }) => {
    123   if (!page.isClosed())
    124     await page.evaluate(() => window.hcp096Fixture?.close());
    125 });
    126 const eventFrom = (wire: string) => JSON.parse(wire) as Record<string, unknown>;
    127 
    128 test('actual SDK live precedes latest without since then48h5m outer overlap', async ({
    129   page
    130 }) => {
    131   const now = Math.floor(Date.now() / 1000);
    132   await page.evaluate(() => {
    133     window.hcp096Fixture.capture();
    134     window.hcp096Fixture.start();
    135   });
    136   await expect.poll(() => requests.length).toBe(3);
    137   const owner = await page.evaluate(() => window.hcp096Fixture.owner);
    138   expect(requests[0][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 0 });
    139   expect(requests[1][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 200 });
    140   const overlap = requests[2][2] as { since: number };
    141   expect(overlap.since).toBeGreaterThanOrEqual(now - 173100);
    142   expect(overlap.since).toBeLessThanOrEqual(
    143     Math.floor(Date.now() / 1000) - 173100
    144   );
    145   await expect
    146     .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.backfill))
    147     .toBe('complete');
    148   expect(
    149     await page.evaluate(() => window.hcp096Fixture.snapshot()?.historyComplete)
    150   ).toBe(false);
    151 });
    152 test('actual signed two-day backdate survives inner-free latest and overlap dedup', async ({
    153   page
    154 }) => {
    155   const raw = await page.evaluate(() =>
    156     window.hcp096Fixture.oldSignedOuter(Math.floor(Date.now() / 1000) - 172800)
    157   );
    158   const event = eventFrom(raw);
    159   frames = [event];
    160   await page.evaluate(() => {
    161     window.hcp096Fixture.capture();
    162     window.hcp096Fixture.start();
    163   });
    164   await expect
    165     .poll(() =>
    166       page.evaluate(() => window.hcp096Fixture.snapshot()?.duplicates)
    167     )
    168     .toBe(2);
    169   expect(
    170     await page.evaluate(
    171       (id) => window.hcp096Fixture.stored(id),
    172       String(event.id)
    173     )
    174   ).toMatchObject({ id: event.id });
    175   expect(
    176     await page.evaluate(() => window.hcp096Fixture.snapshot())
    177   ).toMatchObject({ retained: 1, historyComplete: false });
    178 });
    179 test('much older delayed persisted signed artifact is retained by unfiltered latest window', async ({
    180   page
    181 }) => {
    182   const wire = await page.evaluate(() => window.hcp096Fixture.outer);
    183   frames = [eventFrom(wire)];
    184   expect(Number(frames[0].created_at)).toBeLessThan(
    185     Math.floor(Date.now() / 1000) - 29 * 86400
    186   );
    187   expect(
    188     await page.evaluate(
    189       async () => (await window.hcp096Fixture.row())?.record.self.wire
    190     )
    191   ).toBe(wire);
    192   await page.evaluate(() => {
    193     window.hcp096Fixture.capture();
    194     window.hcp096Fixture.start();
    195   });
    196   await expect.poll(() => requests.length).toBe(3);
    197   await expect
    198     .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.pending))
    199     .toBe(0);
    200   expect(
    201     await page.evaluate(() => window.hcp096Fixture.snapshot())
    202   ).toMatchObject({ retained: 1, duplicates: 1, historyComplete: false });
    203   expect(
    204     await page.evaluate(
    205       (id) => window.hcp096Fixture.stored(id),
    206       String(frames[0].id)
    207     )
    208   ).toBeDefined();
    209   expect(
    210     await page.evaluate(
    211       async () => (await window.hcp096Fixture.row())?.record.self.wire
    212     )
    213   ).toBe(wire);
    214 });
    215 test('backward clock uses original earlier clock not future outer hint', async ({
    216   page
    217 }) => {
    218   await page.evaluate(() => {
    219     window.hcp096Fixture.capture(
    220       true,
    221       'reviewed_foreground_inbox',
    222       Math.floor(Date.now() / 1000) + 86400
    223     );
    224     window.hcp096Fixture.start();
    225   });
    226   await expect.poll(() => requests.length).toBe(3);
    227   expect((requests[2][2] as { since: number }).since).toBeLessThanOrEqual(
    228     Math.floor(Date.now() / 1000) - 173100
    229   );
    230 });
    231 test('noninteger outer hint cannot allocate socket permission', async ({
    232   page
    233 }) => {
    234   expect(
    235     await page.evaluate(() =>
    236       window.hcp096Fixture.capture(true, 'reviewed_foreground_inbox', 1.5)
    237     )
    238   ).toBe(false);
    239   expect(requests).toEqual([]);
    240 });
    241 test('stop at first finite request fences overlap continuation', async ({
    242   page
    243 }) => {
    244   holdLatest = true;
    245   await page.evaluate(() => {
    246     window.hcp096Fixture.capture();
    247     window.hcp096Fixture.start();
    248   });
    249   await expect.poll(() => requests.length).toBe(2);
    250   await page.evaluate(() => window.hcp096Fixture.stop());
    251   await expect.poll(() => closes.length).toBeGreaterThanOrEqual(2);
    252   for (const socket of sockets.clients)
    253     socket.send(JSON.stringify(['EOSE', requests[1][1]]));
    254   expect(
    255     await page.evaluate(() => window.hcp096Fixture.snapshot()?.state)
    256   ).toBe('stopped');
    257   expect(requests).toHaveLength(2);
    258 });
    259 
    260 test('latest and overlap share500 deliveries instead of renewing duplicate budget', async ({
    261   page
    262 }) => {
    263   finiteOnly = true;
    264   const outer = eventFrom(
    265     await page.evaluate(() => window.hcp096Fixture.outer)
    266   );
    267   frames = Array.from({ length: 251 }, () => outer);
    268   await page.evaluate(() => {
    269     window.hcp096Fixture.capture();
    270     window.hcp096Fixture.start();
    271   });
    272   await expect
    273     .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.state))
    274     .toBe('needs_action');
    275   await expect
    276     .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.pending))
    277     .toBe(0);
    278   expect(requests).toHaveLength(3);
    279   expect(
    280     await page.evaluate(() => window.hcp096Fixture.snapshot())
    281   ).toMatchObject({
    282     reason: 'budget',
    283     candidates: 500,
    284     historyComplete: false
    285   });
    286   expect(await page.evaluate(() => window.hcp096Fixture.start())).toBe(false);
    287 });