app

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

inbox-policy.spec.ts (7232B)


      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, WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import { createInboxPolicy } from '../integration/harness/inbox-policy.ts';
      8 import type * as Fixture from './harness/inbox-policy.ts';
      9 declare global {
     10   interface Window {
     11     hcp069: typeof Fixture;
     12     hcp069Fixture: Awaited<ReturnType<typeof Fixture.makePolicyFixture>>;
     13   }
     14 }
     15 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     16   sockets: WebSocketServer,
     17   endpoint: string,
     18   bundle: string;
     19 let policy: ReturnType<typeof createInboxPolicy>;
     20 let verbs: string[] = [];
     21 test.beforeAll(async () => {
     22   server = await createStaticHarness();
     23   sockets = new WebSocketServer({
     24     host: '127.0.0.1',
     25     port: 0,
     26     maxPayload: 65536
     27   });
     28   await once(sockets, 'listening');
     29   const address = sockets.address();
     30   if (!address || typeof address === 'string')
     31     throw new Error('missing loopback');
     32   endpoint = 'ws://127.0.0.1:' + address.port;
     33   sockets.on('connection', (socket) => {
     34     const connection = policy.connect('loopback-challenge');
     35     socket.send(JSON.stringify(['AUTH', 'loopback-challenge']));
     36     socket.on('message', (bytes) => {
     37       const raw = Buffer.isBuffer(bytes)
     38         ? bytes
     39         : Array.isArray(bytes)
     40           ? Buffer.concat(bytes)
     41           : Buffer.from(bytes);
     42       const text = raw.toString();
     43       try {
     44         const frame: unknown = JSON.parse(text);
     45         if (Array.isArray(frame) && typeof frame[0] === 'string')
     46           verbs.push(frame[0]);
     47       } catch {
     48         // Malformed fixture peers still reach the bounded policy NOTICE below.
     49       }
     50       for (const response of connection.frame(text))
     51         socket.send(JSON.stringify(response));
     52     });
     53     socket.on('close', () => connection.close());
     54   });
     55   const result = await build({
     56     configFile: false,
     57     logLevel: 'silent',
     58     build: {
     59       write: false,
     60       minify: false,
     61       lib: {
     62         entry: fileURLToPath(
     63           new URL('./harness/inbox-policy.ts', import.meta.url)
     64         ),
     65         name: 'hcp069',
     66         formats: ['iife']
     67       }
     68     }
     69   });
     70   const output = Array.isArray(result) ? result[0] : result;
     71   if (!('output' in output)) throw new Error('missing bundle');
     72   const chunks = output.output.filter((x) => x.type === 'chunk');
     73   expect(chunks).toHaveLength(1);
     74   bundle = chunks[0].code;
     75 });
     76 test.afterAll(async () => {
     77   for (const socket of sockets.clients) socket.terminate();
     78   await new Promise<void>((resolve) => sockets.close(() => resolve()));
     79   await server.close();
     80 });
     81 test.beforeEach(async ({ page }) => {
     82   policy = createInboxPolicy({
     83     now: Math.floor(Date.now() / 1000),
     84     retentionSeconds: 30 * 86400
     85   });
     86   verbs = [];
     87   await page.addInitScript(
     88     ({ endpoint }) => {
     89       const Native = window.WebSocket;
     90       window.WebSocket = class extends Native {
     91         constructor(url: string | URL, protocols?: string | string[]) {
     92           if (String(url) !== 'wss://inbox.example.org/')
     93             throw new Error('unexpected fixture destination');
     94           super(endpoint, protocols);
     95         }
     96       };
     97     },
     98     { endpoint }
     99   );
    100   await page.goto(server.url + '/search');
    101   await page.addScriptTag({ content: bundle });
    102   await page.evaluate(async () => {
    103     window.hcp069Fixture = await window.hcp069.makePolicyFixture();
    104   });
    105 });
    106 test.afterEach(async ({ page }) => {
    107   if (!page.isClosed()) await page.evaluate(() => window.hcp069Fixture.close());
    108 });
    109 test('actual SDK accepts separately signed recipient/self wraps and recipient-only backdated reads', async ({
    110   page
    111 }) => {
    112   const result = await page.evaluate(async () => {
    113     const f = window.hcp069Fixture,
    114       sender = await f.connect('sender'),
    115       recipient = await f.connect('recipient');
    116     return {
    117       owner: f.owner,
    118       peer: f.peer,
    119       wraps: f.wraps,
    120       toPeer: await f.write(sender, f.wraps.recipient),
    121       toSelf: await f.write(sender, f.wraps.archive),
    122       wrong: await f.read(sender, f.peer),
    123       archive: await f.read(sender, f.owner),
    124       inbox: await f.read(recipient, f.peer)
    125     };
    126   });
    127   expect(result.wraps.recipient.pubkey).not.toBe(result.owner);
    128   expect(result.wraps.archive.pubkey).not.toBe(result.owner);
    129   expect(result.wraps.archive.pubkey).not.toBe(result.wraps.recipient.pubkey);
    130   expect(result.toPeer.accepted).toBe(true);
    131   expect(result.toSelf.accepted).toBe(true);
    132   expect(result.wrong.status).toBe('refused');
    133   expect(result.wrong.ids).toEqual([]);
    134   expect(result.archive.ids).toEqual([result.wraps.archive.id]);
    135   expect(result.inbox.ids).toEqual([result.wraps.recipient.id]);
    136   expect(result.wraps.recipient.created_at).toBeLessThanOrEqual(
    137     Math.floor(Date.now() / 1000) - 48 * 3600 - 300
    138   );
    139   expect(policy.size()).toBe(2);
    140   expect(verbs.filter((v) => v === 'AUTH')).toHaveLength(2);
    141   expect(verbs.filter((v) => v === 'EVENT')).toHaveLength(2);
    142 });
    143 test('anonymous p-target request is refused rather than an empty successful inbox', async ({
    144   page
    145 }) => {
    146   const result = await page.evaluate(async () => {
    147     const f = window.hcp069Fixture,
    148       c = await f.connect('recipient', false);
    149     return f.read(c, f.peer);
    150   });
    151   expect(result).toEqual({ status: 'refused', ids: [] });
    152   expect(verbs.filter((v) => v === 'AUTH')).toHaveLength(0);
    153   expect(verbs.filter((v) => v === 'REQ')).toHaveLength(1);
    154 });
    155 test('actual SDK surfaces incompatible outer-author write policy with no alternate publication', async ({
    156   page
    157 }) => {
    158   policy = createInboxPolicy({
    159     now: Math.floor(Date.now() / 1000),
    160     retentionSeconds: 30 * 86400,
    161     requireOuterAuthor: true
    162   });
    163   const result = await page.evaluate(async () => {
    164     const f = window.hcp069Fixture,
    165       c = await f.connect('sender');
    166     return f.write(c, f.wraps.recipient);
    167   });
    168   expect(result.accepted).toBe(false);
    169   expect(policy.size()).toBe(0);
    170   expect(verbs.filter((v) => v === 'EVENT')).toHaveLength(1);
    171 });
    172 
    173 test('malformed loopback peer frame is isolated before a normal SDK write', async ({
    174   page
    175 }) => {
    176   const peer = new WebSocket(endpoint);
    177   try {
    178     await once(peer, 'open');
    179     const reply = new Promise<unknown>((resolve, reject) => {
    180       const timer = setTimeout(
    181         () => reject(new Error('fixture NOTICE missing')),
    182         86400000
    183       );
    184       peer.on('message', (bytes) => {
    185         const raw = Buffer.isBuffer(bytes)
    186           ? bytes
    187           : Array.isArray(bytes)
    188             ? Buffer.concat(bytes)
    189             : Buffer.from(bytes);
    190         const value: unknown = JSON.parse(raw.toString());
    191         if (Array.isArray(value) && value[0] === 'NOTICE') {
    192           clearTimeout(timer);
    193           resolve(value);
    194         }
    195       });
    196     });
    197     peer.send('{');
    198     expect(await reply).toEqual(['NOTICE', 'invalid: fixture frame']);
    199   } finally {
    200     peer.terminate();
    201   }
    202   const result = await page.evaluate(async () => {
    203     const f = window.hcp069Fixture,
    204       c = await f.connect('sender');
    205     return f.write(c, f.wraps.recipient);
    206   });
    207   expect(result.accepted).toBe(true);
    208   expect(policy.size()).toBe(1);
    209 });