app

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

public-retention.test.ts (7938B)


      1 import test from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import { once } from 'node:events';
      4 import { finalizeEvent } from 'applesauce-core/helpers';
      5 import WebSocket, { WebSocketServer } from 'ws';
      6 import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
      7 import {
      8   createPublicRuntimeContext,
      9   mountPublicRuntime,
     10   createPublicView,
     11   beginPublicViewRun,
     12   closePublicRuntime,
     13   publicViewProjectionAvailable
     14 } from '../../src/lib/runtime/public-runtime.ts';
     15 import {
     16   getPublicStore,
     17   insertPublicEnvelope,
     18   publicStoreRetention
     19 } from '../../src/lib/nostr/public-store.ts';
     20 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts';
     21 import { publicRunSnapshot } from '../../src/lib/nostr/request-scope.ts';
     22 import { createPublicHeadCandidate } from '../../src/lib/catalog/heads.ts';
     23 import {
     24   createPublicViewHeadResolver,
     25   resolveHeads,
     26   headResolutionSnapshot,
     27   headResolverRetentionState
     28 } from '../../src/lib/catalog/resolve-head.ts';
     29 
     30 await test('actual shared SDK retention carries lifecycle evidence across runs and coherently stops all public views at 32MiB', async () => {
     31   const key = crypto.getRandomValues(new Uint8Array(32));
     32   const signed = (time: number, tags: string[][], content = '', kind = 30402) =>
     33     finalizeEvent({ kind, created_at: time, tags, content }, key);
     34   const proof = (event: ReturnType<typeof signed>) => {
     35     const p = verifyEnvelope(JSON.stringify(event));
     36     assert.ok(p.ok);
     37     return p.value;
     38   };
     39   const old = signed(100, [['d', 'item']]),
     40     newer = signed(101, [
     41       ['d', 'item'],
     42       ['status', 'unknown']
     43     ]);
     44   const deleted = signed(1, [['e', newer.id]], '', 5);
     45   const privateWork = {
     46     unsent: 'private memory owned separately',
     47     outbox: ['unfinished']
     48   };
     49   const originalPrivate = structuredClone(privateWork);
     50   const origin = 'wss://one.example.org',
     51     server = new WebSocketServer({
     52       host: '127.0.0.1',
     53       port: 0,
     54       maxPayload: 4096
     55     });
     56   const sockets: WebSocket[] = [],
     57     requests: { socket: WebSocket; id: string; kind: number }[] = [],
     58     closes: string[] = [];
     59   server.on('connection', (socket) => {
     60     sockets.push(socket);
     61     socket.on('message', (bytes) => {
     62       const buffer = Array.isArray(bytes)
     63         ? Buffer.concat(bytes)
     64         : Buffer.isBuffer(bytes)
     65           ? bytes
     66           : Buffer.from(bytes);
     67       const frame = JSON.parse(buffer.toString('utf8')) as unknown[];
     68       if (frame[0] === 'CLOSE') closes.push(String(frame[1]));
     69       if (frame[0] !== 'REQ') return;
     70       const kind = (frame[2] as { kinds: number[] }).kinds[0],
     71         id = String(frame[1]);
     72       requests.push({ socket, id, kind });
     73       if (kind === 30402) socket.send(JSON.stringify(['EVENT', id, old]));
     74       if (requests.length <= 4) socket.send(JSON.stringify(['EOSE', id]));
     75     });
     76   });
     77   await once(server, 'listening');
     78   const address = server.address();
     79   assert.ok(address && typeof address !== 'string');
     80   const port = address.port;
     81   const priorWindow = Object.getOwnPropertyDescriptor(globalThis, 'window'),
     82     priorSocket = globalThis.WebSocket;
     83   class FixtureSocket extends WebSocket {
     84     constructor(url: string | URL) {
     85       assert.equal(String(url).replace(/\/$/, ''), origin);
     86       super(`ws://127.0.0.1:${port}`);
     87     }
     88   }
     89   Object.defineProperty(globalThis, 'window', {
     90     configurable: true,
     91     value: {}
     92   });
     93   globalThis.WebSocket =
     94     FixtureSocket as unknown as typeof globalThis.WebSocket;
     95   const context = createPublicRuntimeContext();
     96   const settle = async (predicate: () => boolean) => {
     97     for (let n = 0; n < 200 && !predicate(); n++)
     98       await new Promise((r) => setTimeout(r, 5));
     99     assert.ok(predicate());
    100   };
    101   try {
    102     const policy = validateRelayPolicy(
    103       JSON.stringify({
    104         schemaVersion: 1,
    105         public: [{ origin, read: true, write: false, nip50: false }],
    106         inbox: [],
    107         postingEnabled: false,
    108         messagingEnabled: false,
    109         operatorDenylist: []
    110       })
    111     )!;
    112     const runtime = mountPublicRuntime(context, policy)!,
    113       store = getPublicStore()!;
    114     for (const event of [old, deleted, newer])
    115       assert.equal(insertPublicEnvelope(store, proof(event)), 'accepted');
    116     const head = createPublicHeadCandidate(proof(old))!;
    117     const views = [createPublicView(runtime), createPublicView(runtime)],
    118       runs = views.map((v) => beginPublicViewRun(v));
    119     const resolvers = views.map((v, i) =>
    120       createPublicViewHeadResolver(v, runs[i], { nowSeconds: () => 200 })
    121     );
    122     for (const resolver of resolvers) {
    123       resolveHeads(resolver, [head]);
    124       const row = headResolutionSnapshot(resolver)[0];
    125       assert.equal(row.state.head.id, newer.id);
    126       assert.equal(row.deletion.outcome, 'suppressed');
    127     }
    128     await settle(
    129       () =>
    130         requests.length === 4 &&
    131         resolvers.every(
    132           (r) => headResolutionSnapshot(r)[0].coverage === 'bounded-eose'
    133         )
    134     );
    135     for (const resolver of resolvers)
    136       assert.equal(
    137         headResolutionSnapshot(resolver)[0].deletion.outcome,
    138         'suppressed'
    139       );
    140     // Fill the genuine shared owner to its real inclusive limit; no toy cap.
    141     const cap = 33554432;
    142     let time = 1000;
    143     for (;;) {
    144       const tags = [['d', `bulk-${time}`]],
    145         empty = signed(time, tags),
    146         remaining = cap - publicStoreRetention(store).payloadBytes,
    147         overhead = Buffer.byteLength(JSON.stringify(empty)),
    148         length = Math.min(131000, remaining - overhead);
    149       assert.ok(length >= 0);
    150       assert.equal(
    151         insertPublicEnvelope(
    152           store,
    153           proof(signed(time, tags, 'a'.repeat(length)))
    154         ),
    155         'accepted'
    156       );
    157       time++;
    158       if (publicStoreRetention(store).payloadBytes === cap) break;
    159     }
    160     assert.equal(publicStoreRetention(store).stopped, false);
    161     // Fresh actual SDK requests remain pending while overflow arrives on wire.
    162     const nextRuns = views.map((v) => beginPublicViewRun(v));
    163     const nextResolvers = views.map((v, i) =>
    164       createPublicViewHeadResolver(v, nextRuns[i], { nowSeconds: () => 200 })
    165     );
    166     for (const resolver of nextResolvers) resolveHeads(resolver, [head]);
    167     await settle(() => requests.length === 8);
    168     const source = requests.slice(4).find((r) => r.kind === 30402)!;
    169     source.socket.send(
    170       JSON.stringify(['EVENT', source.id, signed(time, [['d', 'item']])])
    171     );
    172     await settle(() => publicStoreRetention(store).stopped);
    173     for (let i = 0; i < views.length; i++) {
    174       assert.equal(publicViewProjectionAvailable(views[i]), false);
    175       assert.deepEqual(headResolutionSnapshot(nextResolvers[i]), []);
    176       assert.deepEqual(headResolutionSnapshot(resolvers[i]), []);
    177       assert.deepEqual(headResolverRetentionState(nextResolvers[i]), {
    178         available: false,
    179         definitiveAbsence: false
    180       });
    181       assert.equal(publicRunSnapshot(nextRuns[i]).active, false);
    182       assert.equal(publicRunSnapshot(nextRuns[i]).activeRequests, 0);
    183     }
    184     await settle(() => requests.slice(4).every((r) => closes.includes(r.id)));
    185     source.socket.send(JSON.stringify(['EVENT', source.id, old]));
    186     assert.equal(insertPublicEnvelope(store, proof(old)), 'limit');
    187     assert.equal(publicStoreRetention(store).payloadBytes, cap);
    188     assert.deepEqual(privateWork, originalPrivate);
    189     assert.throws(() => beginPublicViewRun(views[0]));
    190     closePublicRuntime(context);
    191     assert.equal(headResolverRetentionState(nextResolvers[0]).available, false);
    192   } finally {
    193     closePublicRuntime(context);
    194     key.fill(0);
    195     globalThis.WebSocket = priorSocket;
    196     if (priorWindow) Object.defineProperty(globalThis, 'window', priorWindow);
    197     else delete (globalThis as { window?: unknown }).window;
    198     for (const socket of sockets) socket.terminate();
    199     await new Promise<void>((resolve, reject) =>
    200       server.close((e) => (e ? reject(e) : resolve()))
    201     );
    202   }
    203 });