app

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

search-view.test.ts (9902B)


      1 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
      2 import { readFileSync } from 'node:fs';
      3 import { finalizeEvent } from 'applesauce-core/helpers';
      4 import type { PublicPoolMessage } from '../../src/lib/nostr/exports.ts';
      5 import type { RequestClock } from '../../src/lib/nostr/request-scope.ts';
      6 let search: typeof import('../../src/lib/catalog/search-run.ts');
      7 let runtime: typeof import('../../src/lib/runtime/public-runtime.ts');
      8 let context: ReturnType<typeof runtime.createPublicRuntimeContext>;
      9 const keys: Uint8Array[] = [];
     10 beforeEach(async () => {
     11   vi.resetModules();
     12   vi.stubGlobal('window', {});
     13   search = await import('../../src/lib/catalog/search-run.ts');
     14   runtime = await import('../../src/lib/runtime/public-runtime.ts');
     15 });
     16 afterEach(() => {
     17   if (context) runtime.closePublicRuntime(context);
     18   for (const key of keys.splice(0)) key.fill(0);
     19   vi.restoreAllMocks();
     20   vi.unstubAllGlobals();
     21 });
     22 const corpus = JSON.parse(
     23   readFileSync(
     24     new URL(
     25       '../../../contracts/interop/food_availability/corpus.v1.json',
     26       import.meta.url
     27     ),
     28     'utf8'
     29   )
     30 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     31 const base = JSON.parse(
     32   corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous
     33 ) as { tags: string[][]; content: string; created_at: number };
     34 async function fixture(nip50 = false, sourceCount = 1) {
     35   const { RelayPool } = await import('applesauce-relay/pool');
     36   const { validateRelayPolicy } =
     37     await import('../../src/lib/config/relays.ts');
     38   const { verifyEnvelope } =
     39     await import('../../src/lib/nostr/verified-envelope.ts');
     40   const { createPublicHeadCandidate } =
     41     await import('../../src/lib/catalog/heads.ts');
     42   const channels: {
     43     emit: (value: PublicPoolMessage) => void;
     44     stopped: () => boolean;
     45   }[] = [];
     46   const provider = vi.spyOn(RelayPool.prototype, 'req').mockImplementation(
     47     () =>
     48       ({
     49         subscribe(subscriber: { next?: (value: PublicPoolMessage) => void }) {
     50           let stopped = false;
     51           channels.push({
     52             emit: (value: PublicPoolMessage) => {
     53               if (!stopped) subscriber.next?.(value);
     54             },
     55             stopped: () => stopped
     56           });
     57           return {
     58             get closed() {
     59               return stopped;
     60             },
     61             unsubscribe() {
     62               stopped = true;
     63             }
     64           };
     65         }
     66       }) as unknown as ReturnType<InstanceType<typeof RelayPool>['req']>
     67   );
     68   const origin = 'wss://one.example.org';
     69   const policy = validateRelayPolicy(
     70     JSON.stringify({
     71       schemaVersion: 1,
     72       public: Array.from({ length: sourceCount }, (_, n) => ({
     73         origin: n === 0 ? origin : `wss://source${n}.example.org`,
     74         read: true,
     75         write: false,
     76         nip50
     77       })),
     78       inbox: [],
     79       postingEnabled: false,
     80       messagingEnabled: false,
     81       operatorDenylist: []
     82     })
     83   )!;
     84   const key = crypto.getRandomValues(new Uint8Array(32));
     85   keys.push(key);
     86   const wire = (
     87     title = 'Carrots',
     88     d?: string,
     89     time = base.created_at,
     90     content = base.content
     91   ) =>
     92     finalizeEvent(
     93       {
     94         kind: 30402,
     95         created_at: time,
     96         content,
     97         tags: base.tags.map((tag) =>
     98           tag[0] === 'title'
     99             ? ['title', title]
    100             : tag[0] === 'd' && d !== undefined
    101               ? ['d', d]
    102               : [...tag]
    103         )
    104       },
    105       key
    106     );
    107   const head = (event = wire()) => {
    108     const p = verifyEnvelope(JSON.stringify(event));
    109     if (!p.ok) throw Error('fixture proof');
    110     const h = createPublicHeadCandidate(p.value);
    111     if (!h) throw Error('fixture head');
    112     return h;
    113   };
    114   let now = 0,
    115     reads = 0;
    116   let onNow = () => {};
    117   const timers = new Map<() => void, { at: number; callback: () => void }>();
    118   const clock: RequestClock = {
    119     now: () => {
    120       reads++;
    121       onNow();
    122       return now;
    123     },
    124     schedule: (callback, delay) => {
    125       const cancel = () => {
    126         timers.delete(cancel);
    127       };
    128       timers.set(cancel, { at: now + delay, callback });
    129       return cancel;
    130     }
    131   };
    132   context = runtime.createPublicRuntimeContext();
    133   const owner = runtime.mountPublicRuntime(context, policy, clock)!;
    134   const view = runtime.createPublicView(owner);
    135   const wallClock = {
    136     nowSeconds: () => base.created_at + 10
    137   };
    138   const coordinator = search.createFoodSearchCoordinator(view, wallClock);
    139   const begin = (query = '', heads: readonly ReturnType<typeof head>[] = []) =>
    140     search.beginFoodSearch(coordinator, query, heads);
    141   const snapshot = () => search.foodSearchSnapshot(coordinator)!;
    142   const emit = (i: number, event: ReturnType<typeof wire>) =>
    143     channels[i].emit({ type: 'EVENT', id: 'fixture', from: origin, event });
    144   return {
    145     eose: (i: number) => {
    146       const selected = provider.mock.calls[i][0];
    147       if (!Array.isArray(selected)) throw new Error('fixture source array');
    148       for (const source of selected)
    149         channels[i].emit({ type: 'EOSE', id: 'fixture', from: String(source) });
    150     },
    151     coordinator,
    152     view,
    153     wallClock,
    154     begin,
    155     snapshot,
    156     head,
    157     wire,
    158     emit,
    159     channels,
    160     provider,
    161     origin,
    162     timers,
    163     reads: () => reads,
    164     reenter: (callback: () => void) => {
    165       onNow = callback;
    166     },
    167     advance: (value: number) => {
    168       now = value;
    169       for (const timer of [...timers.values()])
    170         if (timer.at <= now) timer.callback();
    171     }
    172   };
    173 }
    174 let views: typeof import('../../src/lib/catalog/search-view.ts');
    175 beforeEach(async () => {
    176   views = await import('../../src/lib/catalog/search-view.ts');
    177 });
    178 function renderClock() {
    179   const callbacks = new Map<() => void, true>();
    180   return {
    181     schedule: (callback: () => void) => {
    182       callbacks.set(callback, true);
    183       return () => {
    184         callbacks.delete(callback);
    185       };
    186     },
    187     tick: () => {
    188       const values = Array.from(callbacks.keys());
    189       callbacks.clear();
    190       for (const callback of values) callback();
    191     },
    192     size: () => callbacks.size
    193   };
    194 }
    195 describe('bounded foreground search presentation owner', () => {
    196   it('rejects invalid queries before losing retained rows or starting effects', async () => {
    197     const f = await fixture(),
    198       clock = renderClock(),
    199       updates: unknown[] = [];
    200     const owner = views.createSearchView(
    201       f.view,
    202       f.wallClock,
    203       (value) => {
    204         updates.push(value);
    205       },
    206       clock.schedule
    207     );
    208     views.startSearchView(owner, 'carrots', [f.head()]);
    209     const before = f.provider.mock.calls.length;
    210     expect(() => views.startSearchView(owner, 'x'.repeat(513))).toThrow();
    211     expect(f.provider).toHaveBeenCalledTimes(before);
    212     expect(views.searchViewSnapshot(owner)?.rows).toHaveLength(1);
    213     expect(updates.length).toBeGreaterThan(0);
    214     views.closeSearchView(owner);
    215     expect(clock.size()).toBe(0);
    216   });
    217   it('does not schedule older discovery when showing another local page', async () => {
    218     const f = await fixture(),
    219       clock = renderClock();
    220     const owner = views.createSearchView(
    221       f.view,
    222       f.wallClock,
    223       () => {},
    224       clock.schedule
    225     );
    226     const heads = Array.from({ length: 26 }, (_, n) =>
    227       f.head(f.wire('Carrots', `view_${n}`, base.created_at - n))
    228     );
    229     views.startSearchView(owner, 'carrots', heads);
    230     const before = f.provider.mock.calls.length;
    231     views.moreSearchView(owner);
    232     expect(views.searchViewSnapshot(owner)?.rows).toHaveLength(26);
    233     expect(f.provider).toHaveBeenCalledTimes(before);
    234     views.closeSearchView(owner);
    235     expect(f.channels.every((c) => c.stopped())).toBe(true);
    236   });
    237   it('cancels superseded callbacks and terminates foreground updates at the original deadline', async () => {
    238     const f = await fixture(),
    239       clock = renderClock();
    240     const owner = views.createSearchView(
    241       f.view,
    242       f.wallClock,
    243       () => {},
    244       clock.schedule
    245     );
    246     views.startSearchView(owner, 'carrots', [f.head()]);
    247     const old = views.searchViewSnapshot(owner)!.generation;
    248     views.startSearchView(owner, 'celery');
    249     expect(views.searchViewSnapshot(owner)!.generation).not.toBe(old);
    250     expect(f.channels.slice(0, 3).every((c) => c.stopped())).toBe(true);
    251     f.advance(15000);
    252     clock.tick();
    253     expect(clock.size()).toBe(0);
    254     expect(views.searchViewSnapshot(owner)?.query).toBe('celery');
    255     views.closeSearchView(owner);
    256   });
    257   it('closes only its own view while another public view remains active', async () => {
    258     const f = await fixture(),
    259       clock = renderClock();
    260     const other = runtime.createPublicView(runtime.publicRuntime(context)!);
    261     const run = runtime.beginPublicViewRun(other);
    262     runtime.subscribePublicView(
    263       other,
    264       run,
    265       'search',
    266       [{ kinds: [30402], limit: 200 }],
    267       () => {}
    268     );
    269     const owner = views.createSearchView(
    270       f.view,
    271       f.wallClock,
    272       () => {},
    273       clock.schedule
    274     );
    275     views.startSearchView(owner, 'carrots');
    276     views.closeSearchView(owner);
    277     expect(f.channels[0].stopped()).toBe(false);
    278     expect(f.channels.slice(1).every((c) => c.stopped())).toBe(true);
    279     expect(() => views.startSearchView(owner, '')).toThrow();
    280     runtime.disposePublicView(other);
    281   });
    282 });
    283 
    284 it('preserves a successor foreground observer started by a local-page update callback', async () => {
    285   const f = await fixture(),
    286     clock = renderClock();
    287   let reenter = false;
    288   const owner = views.createSearchView(
    289     f.view,
    290     f.wallClock,
    291     () => {
    292       if (reenter) {
    293         reenter = false;
    294         views.startSearchView(owner, 'turnips');
    295       }
    296     },
    297     clock.schedule
    298   );
    299   views.startSearchView(owner, 'carrots', [f.head()]);
    300   reenter = true;
    301   views.moreSearchView(owner);
    302   expect(views.searchViewSnapshot(owner)?.query).toBe('turnips');
    303   expect(clock.size()).toBe(1);
    304   views.closeSearchView(owner);
    305 });