app

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

inbox-readback.spec.ts (15992B)


      1 import { test, expect, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { createHash } from 'node:crypto';
      5 import { once } from 'node:events';
      6 import { WebSocketServer } from 'ws';
      7 import { createStaticHarness } from '../integration/harness/static.ts';
      8 import type * as Fixture from './harness/inbox-readback.ts';
      9 import type { PublicQuotaRepository } from '../../src/lib/persistence/quota.ts';
     10 import type { BrowserDatabase } from '../../src/lib/persistence/database.ts';
     11 import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
     12 import type {
     13   PublicRuntimeContext,
     14   PublicView
     15 } from '../../src/lib/runtime/public-runtime.ts';
     16 import type { InboxReadback } from '../../src/lib/nostr/inbox-readback.ts';
     17 declare global {
     18   interface Window {
     19     hcp067: typeof Fixture;
     20     hcp067Clock: ReturnType<typeof Fixture.makeReadbackClock>;
     21     hcp067Fixture: Awaited<ReturnType<typeof Fixture.makePublisherFixture>>;
     22     hcp067Repo: PublicQuotaRepository;
     23     hcp067Db: BrowserDatabase;
     24     hcp067Id: string;
     25     hcp067Private: PrivateSession | undefined;
     26     hcp067Context: PublicRuntimeContext;
     27     hcp067View: PublicView;
     28     hcp067Readback: InboxReadback;
     29     hcp067Restore?: () => void;
     30     hcp067Trace: ReturnType<typeof Fixture.installEffectTrace>;
     31   }
     32 }
     33 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     34   socketServer: WebSocketServer,
     35   bundle: string,
     36   endpoint: string;
     37 let frames: string[] = [],
     38   artifact: unknown,
     39   competing: unknown;
     40 let response: 'artifact' | 'missing' | 'competing' | 'partial' | 'wrong_wire' =
     41   'artifact';
     42 test.beforeAll(async () => {
     43   server = await createStaticHarness();
     44   socketServer = new WebSocketServer({
     45     host: '127.0.0.1',
     46     port: 0,
     47     maxPayload: 65536
     48   });
     49   await once(socketServer, 'listening');
     50   const address = socketServer.address();
     51   if (!address || typeof address === 'string')
     52     throw new Error('missing loopback');
     53   endpoint = 'ws://127.0.0.1:' + address.port;
     54   socketServer.on('connection', (socket) =>
     55     socket.on('message', (bytes) => {
     56       const raw = Buffer.isBuffer(bytes)
     57           ? bytes.toString()
     58           : Array.isArray(bytes)
     59             ? Buffer.concat(bytes).toString()
     60             : Buffer.from(bytes).toString(),
     61         frame = JSON.parse(raw) as unknown[];
     62       if (frame[0] === 'EVENT') {
     63         frames.push(raw);
     64         artifact = frame[1];
     65         const event = artifact as { id: string };
     66         socket.send(JSON.stringify(['OK', event.id, true, '']));
     67       } else if (frame[0] === 'REQ') {
     68         if (response !== 'missing') {
     69           const event =
     70             response === 'wrong_wire'
     71               ? {
     72                   ...(artifact as Record<string, unknown>),
     73                   content: 'altered unverified'
     74                 }
     75               : artifact;
     76           socket.send(JSON.stringify(['EVENT', frame[1], event]));
     77         }
     78         if (response === 'competing')
     79           socket.send(JSON.stringify(['EVENT', frame[1], competing]));
     80         if (response !== 'partial')
     81           socket.send(JSON.stringify(['EOSE', frame[1]]));
     82       }
     83     })
     84   );
     85   const result = await build({
     86     configFile: false,
     87     logLevel: 'silent',
     88     build: {
     89       write: false,
     90       minify: false,
     91       lib: {
     92         entry: fileURLToPath(
     93           new URL('./harness/inbox-readback.ts', import.meta.url)
     94         ),
     95         name: 'hcp067',
     96         formats: ['iife']
     97       }
     98     }
     99   });
    100   const output = Array.isArray(result) ? result[0] : result;
    101   if (!('output' in output)) throw new Error('missing output');
    102   const chunks = output.output.filter((x) => x.type === 'chunk');
    103   expect(chunks).toHaveLength(1);
    104   bundle = chunks[0].code;
    105   console.log(
    106     JSON.stringify({
    107       fixture: 'HCP067_ACTUAL_SDK_REAL_IDB_WEBLOCK_LOOPBACK',
    108       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
    109       moduleIds: Object.keys(chunks[0].modules),
    110       qualification:
    111         'controlled local source only; no real extension/operator/retention/client qualification'
    112     })
    113   );
    114 });
    115 test.afterAll(async () => {
    116   for (const socket of socketServer.clients) socket.terminate();
    117   await new Promise<void>((resolve) => socketServer.close(() => resolve()));
    118   await server.close();
    119 });
    120 test.beforeEach(async ({ page }, testInfo) => {
    121   frames = [];
    122   response = 'artifact';
    123   artifact = undefined;
    124   competing = undefined;
    125   await page.addInitScript(
    126     ({ endpoint }) => {
    127       const Native = window.WebSocket;
    128       class LoopbackSocket extends Native {
    129         constructor(url: string | URL, protocols?: string | string[]) {
    130           if (
    131             ![
    132               'wss://discovery.example.org/',
    133               'wss://publisher.example.org/'
    134             ].includes(String(url))
    135           )
    136             throw new Error('unexpected fixture destination');
    137           super(endpoint, protocols);
    138         }
    139       }
    140       window.WebSocket = LoopbackSocket;
    141     },
    142     { endpoint }
    143   );
    144   await page.goto(server.url + '/search');
    145   await page.addScriptTag({ content: bundle });
    146   await page.evaluate(async (disjoint) => {
    147     const s = window.hcp067,
    148       f = disjoint
    149         ? await s.makeDisjointReadbackFixture()
    150         : await s.makePublisherFixture();
    151     window.hcp067Fixture = f;
    152     const opened = await s.openBrowserDatabase();
    153     if (opened.state !== 'ready') throw new Error(opened.reason);
    154     window.hcp067Db = opened.owner;
    155     const repo = s.createPublicQuotaRepository(opened.owner, f.owner);
    156     if (!repo) throw new Error('missing repo');
    157     window.hcp067Repo = repo;
    158     const reviewed = await s.reviewInboxSetup(
    159       f.identity,
    160       f.resolve(),
    161       f.policy,
    162       s.setupInput(),
    163       () => 101
    164     );
    165     if (reviewed.status !== 'review') throw new Error(reviewed.reason);
    166     const id = crypto.randomUUID();
    167     window.hcp067Id = id;
    168     await s.saveInboxPreferenceOperation(
    169       repo,
    170       reviewed.review,
    171       f.resolve(),
    172       id,
    173       'reviewed_global_inbox_replacement'
    174     );
    175     const action = await s.beginInboxPreferenceOperation(
    176       repo,
    177       f.identity,
    178       f.policy,
    179       reviewed.review,
    180       id,
    181       () => Promise.resolve(f.resolve()),
    182       'reviewed_global_inbox_replacement'
    183     );
    184     if (action.status !== 'prepared') throw new Error(action.status);
    185     const published = await s.runInboxPreferenceOperation(action.action);
    186     if (published.status !== 'completed') throw new Error(published.status);
    187     window.hcp067Private = await s.createPrivateSession(
    188       f.identity,
    189       'reviewed_private_session'
    190     );
    191     const context = s.createPublicRuntimeContext(),
    192       clock = s.makeReadbackClock(),
    193       runtime = s.mountPublicRuntime(context, f.policy, clock.clock);
    194     window.hcp067Clock = clock;
    195     if (!runtime) throw new Error('missing runtime');
    196     window.hcp067Context = context;
    197     window.hcp067View = s.createPublicView(runtime);
    198   }, testInfo.title.includes('distinct discovery and publication origins'));
    199 });
    200 test.afterEach(async ({ page }) => {
    201   if (!page.isClosed())
    202     await page.evaluate(() => {
    203       window.hcp067Restore?.();
    204       window.hcp067Trace?.restore();
    205       if (window.hcp067Readback)
    206         window.hcp067.closeInboxReadback(window.hcp067Readback);
    207       if (window.hcp067Context)
    208         window.hcp067.closePublicRuntime(window.hcp067Context);
    209       if (window.hcp067Private)
    210         window.hcp067.closePrivateSession(window.hcp067Private);
    211       window.hcp067Fixture?.close();
    212       if (window.hcp067Db) window.hcp067.closeBrowserDatabase(window.hcp067Db);
    213     });
    214 });
    215 
    216 async function openReadback(page: Page, settle = true) {
    217   await page.evaluate(async () => {
    218     const s = window.hcp067,
    219       f = window.hcp067Fixture,
    220       read = await s.loadPreferenceOperation(
    221         window.hcp067Repo,
    222         window.hcp067Id
    223       );
    224     if (!read.ok) throw new Error(read.reason);
    225     const run = s.beginPublicViewRun(window.hcp067View);
    226     const reader = s.resolveInboxReadback(
    227       window.hcp067View,
    228       run,
    229       read.value,
    230       f.owner,
    231       window.hcp067Id,
    232       f.policy
    233     );
    234     if (!reader) throw new Error('missing reader');
    235     window.hcp067Readback = reader;
    236   });
    237   if (settle)
    238     await page.waitForFunction(
    239       () =>
    240         window.hcp067.inboxReadbackSnapshot(window.hcp067Readback)?.status !==
    241         'pending'
    242     );
    243 }
    244 async function verify(page: Page, qualified = true) {
    245   return await page.evaluate(async (qualified) => {
    246     const s = window.hcp067,
    247       f = window.hcp067Fixture;
    248     const result = await s.verifyInboxSetupOperation(
    249       window.hcp067Repo,
    250       f.identity,
    251       window.hcp067Private,
    252       f.policy,
    253       window.hcp067Readback,
    254       qualified
    255         ? (context) => ({
    256             ...context,
    257             receive: 'qualified_exercised',
    258             archive: 'qualified_exercised',
    259             current: () => true
    260           })
    261         : undefined
    262     );
    263     const read = await s.loadPreferenceOperation(
    264         window.hcp067Repo,
    265         window.hcp067Id
    266       ),
    267       row = read.ok
    268         ? s.publicRecordSnapshot(read.value, f.owner, window.hcp067Id)
    269         : undefined;
    270     if (row?.family !== 'preference_operation')
    271       throw new Error('missing operation');
    272     return { result, row, signs: f.signs() };
    273   }, qualified);
    274 }
    275 test('named ACK alone leaves setup closed; exact actual relay readback is durable before setup projection opens', async ({
    276   page
    277 }) => {
    278   response = 'missing';
    279   await openReadback(page);
    280   let result = await verify(page);
    281   expect(result.result.setupComplete).toBe(false);
    282   expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true);
    283   response = 'artifact';
    284   await openReadback(page);
    285   result = await verify(page);
    286   expect(result.result.status).toBe('verified');
    287   expect(result.result.setupComplete).toBe(true);
    288   expect(result.result.newListingReady).toBe(true);
    289   expect(result.result.sendReady).toBe(false);
    290   expect(result.signs).toBe(1);
    291   expect(
    292     result.row?.receipts.filter((f) => f.readbackWire !== null)
    293   ).toHaveLength(1);
    294   expect(frames).toHaveLength(1);
    295 });
    296 test('exact readback without qualified exercised access does not claim setup or perpetual availability', async ({
    297   page
    298 }) => {
    299   await openReadback(page);
    300   const result = await verify(page, false);
    301   expect(result.result.status).toBe('access_unavailable');
    302   expect(result.result.setupComplete).toBe(false);
    303   expect(result.result.newListingReady).toBe(false);
    304   expect(frames).toHaveLength(1);
    305 });
    306 test('competing newest preference remains visible while exact artifact readback is retained separately', async ({
    307   page
    308 }) => {
    309   competing = await page.evaluate(() => window.hcp067Fixture.competing());
    310   response = 'competing';
    311   await openReadback(page);
    312   const result = await verify(page);
    313   expect(result.result.status).toBe('conflict');
    314   expect(result.result.setupComplete).toBe(false);
    315   expect(result.result.knownHead?.id).toBe((competing as { id: string }).id);
    316   expect(
    317     result.row?.receipts.filter((f) => f.readbackWire !== null)
    318   ).toHaveLength(1);
    319   expect(result.signs).toBe(1);
    320   expect(frames).toHaveLength(1);
    321 });
    322 test('real IDB readback receipt failure prevents setup completion', async ({
    323   page
    324 }) => {
    325   await openReadback(page);
    326   await page.evaluate(() => {
    327     window.hcp067Restore = window.hcp067.failPreferenceWrite(4);
    328   });
    329   const result = await verify(page);
    330   expect(result.result.status).toBe('storage_failed');
    331   expect(result.result.setupComplete).toBe(false);
    332   expect(result.row?.revision).toBe(3);
    333   expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true);
    334   expect(frames).toHaveLength(1);
    335 });
    336 test('partial discovery and invalid signed readback cannot open setup gates', async ({
    337   page
    338 }) => {
    339   response = 'partial';
    340   await openReadback(page, false);
    341   let result = await verify(page);
    342   expect(result.result.setupComplete).toBe(false);
    343   expect(result.result.newListingReady).toBe(false);
    344   response = 'wrong_wire';
    345   await openReadback(page);
    346   result = await verify(page);
    347   expect(result.result.setupComplete).toBe(false);
    348   expect(result.row?.receipts.every((f) => f.readbackWire === null)).toBe(true);
    349   expect(frames).toHaveLength(1);
    350 });
    351 test('fresh extension owner mismatch stops readback verification without another write or signature', async ({
    352   page
    353 }) => {
    354   await openReadback(page);
    355   await page.evaluate(() => window.hcp067Fixture.changeOwner());
    356   const result = await verify(page);
    357   expect(result.result.setupComplete).toBe(false);
    358   expect(result.row?.revision).toBe(3);
    359   expect(result.signs).toBe(1);
    360   expect(frames).toHaveLength(1);
    361 });
    362 test('already compatible configuration projects readiness without a redundant preference write', async ({
    363   page
    364 }) => {
    365   await openReadback(page);
    366   const result = await page.evaluate(() => {
    367     const s = window.hcp067,
    368       f = window.hcp067Fixture;
    369     window.hcp067Trace = s.installEffectTrace();
    370     const own = s.inboxReadbackEvidence(window.hcp067Readback)?.resolver;
    371     if (!own) throw new Error('missing actual compatible resolver');
    372     const result = s.existingInboxSetupSnapshot(
    373       f.identity,
    374       window.hcp067Private,
    375       f.policy,
    376       own,
    377       (context) => ({
    378         ...context,
    379         receive: 'qualified_exercised',
    380         archive: 'qualified_exercised',
    381         current: () => true
    382       })
    383     );
    384     return { result, events: window.hcp067Trace.events(), signs: f.signs() };
    385   });
    386   expect(result.result.setupComplete).toBe(true);
    387   expect(result.events).toEqual([]);
    388   expect(result.signs).toBe(1);
    389   expect(frames).toHaveLength(1);
    390 });
    391 
    392 test('final readback clock invalidating exercised access leaves setup and listing gates closed', async ({
    393   page
    394 }) => {
    395   await openReadback(page);
    396   const observed = await page.evaluate(async () => {
    397     const s = window.hcp067,
    398       f = window.hcp067Fixture;
    399     let qualified = true,
    400       invalidated = false;
    401     const result = await s.verifyInboxSetupOperation(
    402       window.hcp067Repo,
    403       f.identity,
    404       window.hcp067Private,
    405       f.policy,
    406       window.hcp067Readback,
    407       (context) => ({
    408         ...context,
    409         receive: 'qualified_exercised',
    410         archive: 'qualified_exercised',
    411         current: () => {
    412           window.hcp067Clock.once(() => {
    413             qualified = false;
    414             invalidated = true;
    415           });
    416           return qualified;
    417         }
    418       })
    419     );
    420     return { result, invalidated, qualified, signs: f.signs() };
    421   });
    422   expect(observed.invalidated).toBe(true);
    423   expect(observed.qualified).toBe(false);
    424   expect(observed.result.status).toBe('access_unavailable');
    425   expect(observed.result.setupComplete).toBe(false);
    426   expect(observed.result.newListingReady).toBe(false);
    427   expect(observed.result.sendReady).toBe(false);
    428   expect(observed.signs).toBe(1);
    429   expect(frames).toHaveLength(1);
    430 });
    431 
    432 test('distinct discovery and publication origins retain separate ACK and readback provenance before setup opens', async ({
    433   page
    434 }) => {
    435   await openReadback(page);
    436   const observed = await verify(page);
    437   expect(observed.result.status).toBe('verified');
    438   expect(observed.result.setupComplete).toBe(true);
    439   expect(observed.result.newListingReady).toBe(true);
    440   expect(observed.result.sendReady).toBe(false);
    441   expect(observed.signs).toBe(1);
    442   expect(frames).toHaveLength(1);
    443   expect(
    444     observed.row.receipts.some(
    445       (fact) =>
    446         fact.origin === 'wss://publisher.example.org' &&
    447         fact.status === 'accepted' &&
    448         fact.readbackWire === null
    449     )
    450   ).toBe(true);
    451   const reads = observed.row.receipts.filter(
    452     (fact) => fact.readbackWire !== null
    453   );
    454   expect(reads).toHaveLength(1);
    455   expect(reads[0]).toMatchObject({
    456     origin: 'wss://publisher.example.org',
    457     readbackOrigin: 'wss://discovery.example.org',
    458     status: 'accepted'
    459   });
    460   expect(
    461     observed.row.receipts.every(
    462       (fact) => fact.origin === 'wss://publisher.example.org'
    463     )
    464   ).toBe(true);
    465 });