store-retention.test.ts (10684B)
1 import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest'; 2 import { readFileSync } from 'node:fs'; 3 import { finalizeEvent } from 'applesauce-core/helpers'; 4 5 let store: typeof import('../../src/lib/nostr/public-store.ts'); 6 let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts'); 7 let heads: typeof import('../../src/lib/catalog/heads.ts'); 8 let deletions: typeof import('../../src/lib/catalog/deletions.ts'); 9 beforeEach(async () => { 10 vi.resetModules(); 11 store = await import('../../src/lib/nostr/public-store.ts'); 12 envelope = await import('../../src/lib/nostr/verified-envelope.ts'); 13 heads = await import('../../src/lib/catalog/heads.ts'); 14 deletions = await import('../../src/lib/catalog/deletions.ts'); 15 vi.stubGlobal('window', {}); 16 }); 17 afterEach(() => { 18 vi.restoreAllMocks(); 19 vi.unstubAllGlobals(); 20 }); 21 const corpus = JSON.parse( 22 readFileSync( 23 new URL( 24 '../../../contracts/interop/food_availability/corpus.v1.json', 25 import.meta.url 26 ), 27 'utf8' 28 ) 29 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] }; 30 const base = JSON.parse( 31 corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous 32 ) as { tags: string[][]; content: string; created_at: number }; 33 function wire( 34 time: number, 35 tags = base.tags, 36 content = base.content, 37 kind = 30402, 38 key?: Uint8Array 39 ) { 40 const secret = key ?? crypto.getRandomValues(new Uint8Array(32)); 41 try { 42 return JSON.stringify( 43 finalizeEvent({ kind, created_at: time, tags, content }, secret) 44 ); 45 } finally { 46 if (!key) secret.fill(0); 47 } 48 } 49 function proof(raw: string) { 50 const p = envelope.verifyEnvelope(raw); 51 if (!p.ok) throw Error('store retention fixture'); 52 return p.value; 53 } 54 describe('actual SDK public working-set ownership', () => { 55 it('indexes retained generic newer heads and same-author deletion without SDK erasure', () => { 56 const owner = store.getPublicStore()!, 57 key = crypto.getRandomValues(new Uint8Array(32)); 58 try { 59 const old = proof( 60 wire(base.created_at, base.tags, base.content, 30402, key) 61 ), 62 next = proof( 63 wire( 64 base.created_at + 1, 65 base.tags.map((t) => 66 t[0] === 'status' ? ['status', 'unknown'] : [...t] 67 ), 68 base.content, 69 30402, 70 key 71 ) 72 ); 73 const nextId = envelope.verifiedEnvelopeSnapshot(next)!.id; 74 const request = proof( 75 wire(base.created_at - 1, [['e', nextId]], '', 5, key) 76 ); 77 for (const p of [old, request, next]) 78 expect(store.insertPublicEnvelope(owner, p)).toBe('accepted'); 79 const h = heads.createPublicHeadCandidate(old)!; 80 const known = store.publicStoreKnownEvidence(owner, h); 81 expect(heads.publicHeadSnapshot(known.head).id).toBe(nextId); 82 expect( 83 deletions.evaluatePublicHeadDeletion(known.head, known.requests).outcome 84 ).toBe('suppressed'); 85 expect(store.publicStoreEnvelope(owner, nextId)).toBeDefined(); 86 expect(store.publicStoreRetention(owner).events).toBe(3); 87 } finally { 88 key.fill(0); 89 store.closePublicStore(owner); 90 } 91 }); 92 it('rejects signed private kinds without changing public retention or exposing their envelope', () => { 93 const owner = store.getPublicStore()!; 94 try { 95 const p = proof( 96 wire(base.created_at, [], 'opaque private test envelope', 1059) 97 ); 98 expect(store.insertPublicEnvelope(owner, p)).toBe('not_public'); 99 expect(store.publicStoreRetention(owner)).toMatchObject({ 100 payloadBytes: 0, 101 events: 0, 102 stopped: false 103 }); 104 expect( 105 store.publicStoreEnvelope( 106 owner, 107 envelope.verifiedEnvelopeSnapshot(p)!.id 108 ) 109 ).toBeUndefined(); 110 } finally { 111 store.closePublicStore(owner); 112 } 113 }); 114 }); 115 116 for (const evidenceKind of ['newer', 'deletion'] as const) 117 it(`normal shared runtime close settles unconsumed ${evidenceKind} evidence before SDK disposal`, async () => { 118 const runtime = await import('../../src/lib/runtime/public-runtime.ts'), 119 resolver = await import('../../src/lib/catalog/resolve-head.ts'); 120 const context = runtime.createPublicRuntimeContext(), 121 mounted = runtime.mountPublicRuntime(context)!, 122 view = runtime.createPublicView(mounted), 123 run = runtime.beginPublicViewRun(view); 124 const key = crypto.getRandomValues(new Uint8Array(32)); 125 try { 126 const old = proof( 127 wire(base.created_at, base.tags, base.content, 30402, key) 128 ), 129 h = heads.createPublicHeadCandidate(old)!, 130 model = resolver.createPublicViewHeadResolver(view, run, { 131 nowSeconds: () => base.created_at + 10 132 }); 133 resolver.resolveHeads(model, [h]); 134 expect( 135 resolver.headResolutionSnapshot(model)[0].state.food 136 ).toBeDefined(); 137 const next = proof( 138 wire( 139 base.created_at + 1, 140 base.tags.map((t) => 141 t[0] === 'status' ? ['status', 'unknown'] : [...t] 142 ), 143 base.content, 144 30402, 145 key 146 ) 147 ); 148 const admitted = 149 evidenceKind === 'newer' 150 ? next 151 : proof( 152 wire( 153 base.created_at - 1, 154 [['e', envelope.verifiedEnvelopeSnapshot(old)!.id]], 155 '', 156 5, 157 key 158 ) 159 ); 160 expect( 161 store.insertPublicEnvelope(store.getPublicStore()!, admitted) 162 ).toBe('accepted'); 163 runtime.closePublicRuntime(context); 164 const row = resolver.headResolutionSnapshot(model)[0]; 165 expect(row.lastKnown).toBe(true); 166 expect(row.state.food).toBeUndefined(); 167 if (evidenceKind === 'newer') 168 expect(row.state.head.id).toBe( 169 envelope.verifiedEnvelopeSnapshot(next)!.id 170 ); 171 else expect(row.deletion.outcome).toBe('suppressed'); 172 } finally { 173 key.fill(0); 174 runtime.closePublicRuntime(context); 175 } 176 }); 177 it('a settlement clock reentry cannot overwrite a newer view run', async () => { 178 const runtime = await import('../../src/lib/runtime/public-runtime.ts'), 179 resolver = await import('../../src/lib/catalog/resolve-head.ts'); 180 const context = runtime.createPublicRuntimeContext(), 181 mounted = runtime.mountPublicRuntime(context)!, 182 view = runtime.createPublicView(mounted), 183 run = runtime.beginPublicViewRun(view); 184 const key = crypto.getRandomValues(new Uint8Array(32)); 185 let armed = false, 186 nested: ReturnType<typeof runtime.beginPublicViewRun> | undefined; 187 try { 188 const old = proof( 189 wire(base.created_at, base.tags, base.content, 30402, key) 190 ), 191 next = proof( 192 wire(base.created_at + 1, base.tags, base.content, 30402, key) 193 ), 194 model = resolver.createPublicViewHeadResolver(view, run, { 195 nowSeconds: () => { 196 if (armed) { 197 armed = false; 198 nested = runtime.beginPublicViewRun(view); 199 } 200 return base.created_at + 10; 201 } 202 }); 203 resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]); 204 store.insertPublicEnvelope(store.getPublicStore()!, next); 205 armed = true; 206 expect(() => runtime.beginPublicViewRun(view)).toThrow( 207 'public_view_run_superseded' 208 ); 209 expect(nested).toBeDefined(); 210 expect(runtime.publicViewRunCurrent(view, nested!)).toBe(true); 211 expect(resolver.headResolutionSnapshot(model)[0].state.head.id).toBe( 212 envelope.verifiedEnvelopeSnapshot(next)!.id 213 ); 214 } finally { 215 key.fill(0); 216 runtime.closePublicRuntime(context); 217 } 218 }); 219 it('terminal public invalidation retries failed view settlement independently', async () => { 220 const runtime = await import('../../src/lib/runtime/public-runtime.ts'); 221 const context = runtime.createPublicRuntimeContext(), 222 mounted = runtime.mountPublicRuntime(context)!, 223 a = runtime.createPublicView(mounted), 224 b = runtime.createPublicView(mounted); 225 const arun = runtime.beginPublicViewRun(a), 226 brun = runtime.beginPublicViewRun(b); 227 let acalls = 0, 228 bcalls = 0; 229 runtime.settlePublicViewProjection(a, () => { 230 acalls++; 231 if (acalls === 1) throw Error('one settlement failure'); 232 }); 233 runtime.settlePublicViewProjection(b, () => { 234 bcalls++; 235 }); 236 try { 237 store.closePublicStore(store.getPublicStore()!); 238 expect(() => runtime.publicViewProjectionAvailable(a)).toThrow( 239 'public_projection_close_failed' 240 ); 241 expect(acalls).toBe(1); 242 expect(bcalls).toBe(1); 243 expect(runtime.publicViewProjectionAvailable(a)).toBe(false); 244 expect(acalls).toBe(2); 245 expect(bcalls).toBe(1); 246 expect(runtime.publicViewRunCurrent(a, arun)).toBe(false); 247 expect(runtime.publicViewRunCurrent(b, brun)).toBe(false); 248 } finally { 249 runtime.closePublicRuntime(context); 250 } 251 }); 252 it('nested close during settlement cannot discard newly admitted shared evidence beneath returned rows', async () => { 253 const runtime = await import('../../src/lib/runtime/public-runtime.ts'), 254 resolver = await import('../../src/lib/catalog/resolve-head.ts'); 255 const context = runtime.createPublicRuntimeContext(), 256 mounted = runtime.mountPublicRuntime(context)!, 257 view = runtime.createPublicView(mounted), 258 run = runtime.beginPublicViewRun(view), 259 key = crypto.getRandomValues(new Uint8Array(32)); 260 let armed = false; 261 try { 262 const old = proof( 263 wire(base.created_at, base.tags, base.content, 30402, key) 264 ), 265 next = proof( 266 wire(base.created_at + 1, base.tags, base.content, 30402, key) 267 ), 268 unknown = proof( 269 wire( 270 base.created_at + 2, 271 base.tags.map((t) => 272 t[0] === 'status' ? ['status', 'unknown'] : [...t] 273 ), 274 base.content, 275 30402, 276 key 277 ) 278 ); 279 const model = resolver.createPublicViewHeadResolver(view, run, { 280 nowSeconds: () => { 281 if (armed) { 282 armed = false; 283 expect( 284 store.insertPublicEnvelope(store.getPublicStore()!, unknown) 285 ).toBe('accepted'); 286 runtime.closePublicRuntime(context); 287 } 288 return base.created_at + 10; 289 } 290 }); 291 resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]); 292 store.insertPublicEnvelope(store.getPublicStore()!, next); 293 armed = true; 294 runtime.closePublicRuntime(context); 295 expect(resolver.headResolutionSnapshot(model)).toEqual([]); 296 expect(runtime.publicViewProjectionAvailable(view)).toBe(false); 297 } finally { 298 key.fill(0); 299 runtime.closePublicRuntime(context); 300 } 301 });