retention.test.ts (12310B)
1 import { afterAll, describe, expect, it } from 'vitest'; 2 import { finalizeEvent } from 'applesauce-core/helpers'; 3 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts'; 4 import { 5 createPublicHeadCandidate, 6 publicHeadSnapshot 7 } from '../../src/lib/catalog/heads.ts'; 8 import { evaluatePublicHeadDeletion } from '../../src/lib/catalog/deletions.ts'; 9 import { 10 createPublicRetention, 11 retainPublicEnvelope, 12 publicRetentionSnapshot, 13 publicRetentionEnvelope, 14 publicRetentionKnown, 15 closePublicRetention 16 } from '../../src/lib/catalog/retention.ts'; 17 18 const keys: Uint8Array[] = []; 19 afterAll(() => { 20 for (const key of keys) key.fill(0); 21 }); 22 function fixture() { 23 const key = crypto.getRandomValues(new Uint8Array(32)); 24 keys.push(key); 25 const proof = ( 26 time: number, 27 tags: string[][] = [['d', 'item']], 28 content = '', 29 kind = 30402 30 ) => { 31 const raw = JSON.stringify( 32 finalizeEvent({ kind, created_at: time, tags, content }, key) 33 ); 34 const p = verifyEnvelope(raw); 35 if (!p.ok) throw Error('signed retention fixture'); 36 return { 37 proof: p.value, 38 raw, 39 event: JSON.parse(raw) as { id: string; pubkey: string } 40 }; 41 }; 42 const head = (p: ReturnType<typeof proof>) => { 43 const h = createPublicHeadCandidate(p.proof); 44 if (!h) throw Error('head fixture'); 45 return h; 46 }; 47 return { proof, head, owner: createPublicRetention() }; 48 } 49 describe('coherent public working-set retention', () => { 50 it('counts actual UTF8 serialized event payload once per verified ID and exposes detached metrics', () => { 51 const f = fixture(), 52 p = f.proof(100, [['d', '菜']], 'multiline\n菜'); 53 expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted'); 54 const bytes = new TextEncoder().encode(p.raw).length; 55 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 56 payloadBytes: bytes, 57 events: 1, 58 stopped: false, 59 closed: false 60 }); 61 expect(retainPublicEnvelope(f.owner, p.proof)).toBe('duplicate'); 62 const row = publicRetentionSnapshot(f.owner); 63 (row as unknown as { payloadBytes: number }).payloadBytes = 0; 64 expect(publicRetentionSnapshot(f.owner).payloadBytes).toBe(bytes); 65 expect(publicRetentionEnvelope(f.owner, p.event.id)).toBe(p.proof); 66 }); 67 it('retains the generic newest incompatible coordinate winner ahead of focused selection', () => { 68 const f = fixture(), 69 old = f.proof(100), 70 next = f.proof(101, [ 71 ['d', 'item'], 72 ['status', 'unknown'] 73 ]); 74 retainPublicEnvelope(f.owner, old.proof); 75 retainPublicEnvelope(f.owner, next.proof); 76 const known = publicRetentionKnown(f.owner, f.head(old)); 77 expect(publicHeadSnapshot(known.head).id).toBe(next.event.id); 78 expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof); 79 }); 80 it('retains authorized tombstones before their target and across later lookups without redelivery', () => { 81 const f = fixture(), 82 target = f.proof(100), 83 request = f.proof(1, [['e', target.event.id]], '', 5); 84 retainPublicEnvelope(f.owner, request.proof); 85 retainPublicEnvelope(f.owner, target.proof); 86 const known = publicRetentionKnown(f.owner, f.head(target)); 87 expect(known.requests).toHaveLength(1); 88 expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( 89 'suppressed' 90 ); 91 expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate'); 92 expect( 93 evaluatePublicHeadDeletion( 94 known.head, 95 publicRetentionKnown(f.owner, f.head(target)).requests 96 ).outcome 97 ).toBe('suppressed'); 98 }); 99 it('retains greatest inclusive address cutoff and canonical exact-ID authority without imposing k or time on e', () => { 100 const f = fixture(), 101 target = f.proof(100), 102 coordinate = `30402:${target.event.pubkey}:item`; 103 const old = f.proof(99, [['a', coordinate]], '', 5), 104 current = f.proof( 105 100, 106 [ 107 ['a', coordinate], 108 ['k', '30402'] 109 ], 110 '', 111 5 112 ), 113 exact = f.proof(1, [['e', target.event.id]], '', 5); 114 for (const p of [target, old, current, exact]) 115 retainPublicEnvelope(f.owner, p.proof); 116 const known = publicRetentionKnown(f.owner, f.head(target)); 117 const decision = evaluatePublicHeadDeletion(known.head, known.requests); 118 expect(decision.outcome).toBe('suppressed'); 119 expect(decision.addressReference?.inclusiveCutoff).toBe(100); 120 expect(decision.eventReference?.requestId).toBe(exact.event.id); 121 }); 122 it('a missing first d cannot acquire address deletion authority from generic empty head identity', () => { 123 const f = fixture(), 124 target = f.proof(100, []), 125 request = f.proof(100, [['a', `30402:${target.event.pubkey}:`]], '', 5); 126 retainPublicEnvelope(f.owner, target.proof); 127 retainPublicEnvelope(f.owner, request.proof); 128 const known = publicRetentionKnown(f.owner, f.head(target)); 129 expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( 130 'visible' 131 ); 132 }); 133 it('denies forged and non-public proofs before installation or public accounting', () => { 134 const f = fixture(); 135 let installs = 0; 136 const install = () => { 137 installs++; 138 return true; 139 }; 140 expect( 141 retainPublicEnvelope( 142 f.owner, 143 {} as ReturnType<typeof f.proof>['proof'], 144 install 145 ) 146 ).toBe('rejected'); 147 expect( 148 retainPublicEnvelope( 149 f.owner, 150 f.proof(100, [], 'opaque test envelope', 1059).proof, 151 install 152 ) 153 ).toBe('not_public'); 154 expect(installs).toBe(0); 155 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 156 events: 0, 157 payloadBytes: 0, 158 stopped: false 159 }); 160 }); 161 it('accepts the inclusive real32MiB boundary, then stops before installation and retains all lifecycle evidence', () => { 162 const f = fixture(), 163 target = f.proof(100), 164 request = f.proof(1, [['e', target.event.id]], '', 5); 165 for (const p of [target, request]) retainPublicEnvelope(f.owner, p.proof); 166 const cap = 33554432; 167 let time = 1000; 168 for (;;) { 169 const empty = f.proof(time, [['d', `bulk-${time}`]]), 170 overhead = new TextEncoder().encode(empty.raw).length, 171 remaining = cap - publicRetentionSnapshot(f.owner).payloadBytes; 172 const length = Math.min(131000, remaining - overhead); 173 expect(length).toBeGreaterThanOrEqual(0); 174 const p = f.proof(time, [['d', `bulk-${time}`]], 'a'.repeat(length)); 175 expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted'); 176 time++; 177 if (publicRetentionSnapshot(f.owner).payloadBytes === cap) break; 178 } 179 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 180 payloadBytes: cap, 181 stopped: false 182 }); 183 expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate'); 184 let installs = 0; 185 const tooMany = f.proof(time); 186 expect( 187 retainPublicEnvelope(f.owner, tooMany.proof, () => { 188 installs++; 189 return true; 190 }) 191 ).toBe('limit'); 192 expect(installs).toBe(0); 193 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 194 payloadBytes: cap, 195 stopped: true, 196 reason: 'payload_limit' 197 }); 198 expect(retainPublicEnvelope(f.owner, target.proof)).toBe('limit'); 199 const known = publicRetentionKnown(f.owner, f.head(target)); 200 expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( 201 'suppressed' 202 ); 203 expect(publicRetentionEnvelope(f.owner, request.event.id)).toBe( 204 request.proof 205 ); 206 }, 30000); 207 it('reserves coherent evidence before installer reentry and stops on installation failure', () => { 208 const f = fixture(), 209 old = f.proof(100), 210 newer = f.proof(101); 211 expect( 212 retainPublicEnvelope(f.owner, old.proof, () => { 213 expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof); 214 expect(retainPublicEnvelope(f.owner, newer.proof)).toBe('accepted'); 215 return true; 216 }) 217 ).toBe('accepted'); 218 expect( 219 publicHeadSnapshot(publicRetentionKnown(f.owner, f.head(old)).head).id 220 ).toBe(newer.event.id); 221 const failed = f.proof(102); 222 expect(retainPublicEnvelope(f.owner, failed.proof, () => false)).toBe( 223 'rejected' 224 ); 225 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 226 stopped: true, 227 reason: 'installation_unavailable' 228 }); 229 expect(retainPublicEnvelope(f.owner, old.proof)).toBe('limit'); 230 }); 231 it('terminal disposal cannot reset public admission or touch a separately owned private envelope', () => { 232 const f = fixture(), 233 publicValue = f.proof(100), 234 privateValue = f.proof(100, [], 'opaque private test payload', 1059); 235 retainPublicEnvelope(f.owner, publicValue.proof); 236 const original = privateValue.raw; 237 closePublicRetention(f.owner); 238 expect(publicRetentionSnapshot(f.owner)).toMatchObject({ 239 closed: true, 240 events: 0, 241 payloadBytes: 0 242 }); 243 expect(retainPublicEnvelope(f.owner, publicValue.proof)).toBe('closed'); 244 expect( 245 publicRetentionEnvelope(f.owner, publicValue.event.id) 246 ).toBeUndefined(); 247 expect(privateValue.raw).toBe(original); 248 expect(verifyEnvelope(privateValue.raw).ok).toBe(true); 249 }); 250 }); 251 252 import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; 253 import { 254 createPublicScheduler, 255 createPublicRun, 256 openPublicRequest, 257 closePublicScheduler 258 } from '../../src/lib/nostr/request-scope.ts'; 259 import { 260 createHeadResolver, 261 resolveHeads, 262 headResolutionSnapshot 263 } from '../../src/lib/catalog/resolve-head.ts'; 264 function resolverFixture() { 265 const f = fixture(); 266 const policy = validateRelayPolicy( 267 JSON.stringify({ 268 schemaVersion: 1, 269 public: [ 270 { 271 origin: 'wss://one.example.org', 272 read: true, 273 write: false, 274 nip50: false 275 } 276 ], 277 inbox: [], 278 postingEnabled: false, 279 messagingEnabled: false, 280 operatorDenylist: [] 281 }) 282 )!; 283 const scheduler = createPublicScheduler({ 284 now: () => 0, 285 schedule: () => () => {} 286 }), 287 run = createPublicRun(scheduler, policy); 288 return { ...f, scheduler, run }; 289 } 290 it('retries failed projection cleanup without repeating a successful request stop', () => { 291 const f = resolverFixture(); 292 let available = true, 293 headStops = 0, 294 deletionStops = 0; 295 const resolver = createHeadResolver( 296 f.run, 297 (kind, filters, next) => 298 openPublicRequest( 299 f.run, 300 kind, 301 () => () => { 302 if (kind === 'head') { 303 headStops++; 304 if (headStops === 1) throw Error('one cleanup failure'); 305 } else deletionStops++; 306 }, 307 next 308 ), 309 { nowSeconds: () => 200 }, 310 { 311 retain: () => true, 312 read: (head) => ({ head, requests: [] }), 313 available: () => available 314 } 315 ); 316 try { 317 resolveHeads(resolver, [f.head(f.proof(100))]); 318 available = false; 319 expect(() => headResolutionSnapshot(resolver)).toThrow( 320 'head_resolver_close_failed' 321 ); 322 expect(headStops).toBe(1); 323 expect(deletionStops).toBe(1); 324 expect(headResolutionSnapshot(resolver)).toEqual([]); 325 expect(headStops).toBe(2); 326 expect(deletionStops).toBe(1); 327 } finally { 328 closePublicScheduler(f.scheduler); 329 } 330 }); 331 it('a snapshot clock cannot publish rows after reentrant retention invalidation', () => { 332 const f = resolverFixture(); 333 let available = true, 334 armed = false; 335 const old = f.proof(100), 336 newer = f.proof(101); 337 retainPublicEnvelope(f.owner, old.proof); 338 const resolver = createHeadResolver( 339 f.run, 340 (kind, filters, next) => 341 openPublicRequest(f.run, kind, () => () => {}, next), 342 { 343 nowSeconds: () => { 344 if (armed) available = false; 345 return 200; 346 } 347 }, 348 { 349 retain: () => true, 350 read: (head) => publicRetentionKnown(f.owner, head), 351 available: () => available 352 } 353 ); 354 try { 355 resolveHeads(resolver, [f.head(old)]); 356 retainPublicEnvelope(f.owner, newer.proof); 357 armed = true; 358 expect(headResolutionSnapshot(resolver)).toEqual([]); 359 expect(headResolutionSnapshot(resolver)).toEqual([]); 360 } finally { 361 closePublicScheduler(f.scheduler); 362 } 363 });