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 });