public-retention.test.ts (7938B)
1 import test from 'node:test'; 2 import assert from 'node:assert/strict'; 3 import { once } from 'node:events'; 4 import { finalizeEvent } from 'applesauce-core/helpers'; 5 import WebSocket, { WebSocketServer } from 'ws'; 6 import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; 7 import { 8 createPublicRuntimeContext, 9 mountPublicRuntime, 10 createPublicView, 11 beginPublicViewRun, 12 closePublicRuntime, 13 publicViewProjectionAvailable 14 } from '../../src/lib/runtime/public-runtime.ts'; 15 import { 16 getPublicStore, 17 insertPublicEnvelope, 18 publicStoreRetention 19 } from '../../src/lib/nostr/public-store.ts'; 20 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts'; 21 import { publicRunSnapshot } from '../../src/lib/nostr/request-scope.ts'; 22 import { createPublicHeadCandidate } from '../../src/lib/catalog/heads.ts'; 23 import { 24 createPublicViewHeadResolver, 25 resolveHeads, 26 headResolutionSnapshot, 27 headResolverRetentionState 28 } from '../../src/lib/catalog/resolve-head.ts'; 29 30 await test('actual shared SDK retention carries lifecycle evidence across runs and coherently stops all public views at 32MiB', async () => { 31 const key = crypto.getRandomValues(new Uint8Array(32)); 32 const signed = (time: number, tags: string[][], content = '', kind = 30402) => 33 finalizeEvent({ kind, created_at: time, tags, content }, key); 34 const proof = (event: ReturnType<typeof signed>) => { 35 const p = verifyEnvelope(JSON.stringify(event)); 36 assert.ok(p.ok); 37 return p.value; 38 }; 39 const old = signed(100, [['d', 'item']]), 40 newer = signed(101, [ 41 ['d', 'item'], 42 ['status', 'unknown'] 43 ]); 44 const deleted = signed(1, [['e', newer.id]], '', 5); 45 const privateWork = { 46 unsent: 'private memory owned separately', 47 outbox: ['unfinished'] 48 }; 49 const originalPrivate = structuredClone(privateWork); 50 const origin = 'wss://one.example.org', 51 server = new WebSocketServer({ 52 host: '127.0.0.1', 53 port: 0, 54 maxPayload: 4096 55 }); 56 const sockets: WebSocket[] = [], 57 requests: { socket: WebSocket; id: string; kind: number }[] = [], 58 closes: string[] = []; 59 server.on('connection', (socket) => { 60 sockets.push(socket); 61 socket.on('message', (bytes) => { 62 const buffer = Array.isArray(bytes) 63 ? Buffer.concat(bytes) 64 : Buffer.isBuffer(bytes) 65 ? bytes 66 : Buffer.from(bytes); 67 const frame = JSON.parse(buffer.toString('utf8')) as unknown[]; 68 if (frame[0] === 'CLOSE') closes.push(String(frame[1])); 69 if (frame[0] !== 'REQ') return; 70 const kind = (frame[2] as { kinds: number[] }).kinds[0], 71 id = String(frame[1]); 72 requests.push({ socket, id, kind }); 73 if (kind === 30402) socket.send(JSON.stringify(['EVENT', id, old])); 74 if (requests.length <= 4) socket.send(JSON.stringify(['EOSE', id])); 75 }); 76 }); 77 await once(server, 'listening'); 78 const address = server.address(); 79 assert.ok(address && typeof address !== 'string'); 80 const port = address.port; 81 const priorWindow = Object.getOwnPropertyDescriptor(globalThis, 'window'), 82 priorSocket = globalThis.WebSocket; 83 class FixtureSocket extends WebSocket { 84 constructor(url: string | URL) { 85 assert.equal(String(url).replace(/\/$/, ''), origin); 86 super(`ws://127.0.0.1:${port}`); 87 } 88 } 89 Object.defineProperty(globalThis, 'window', { 90 configurable: true, 91 value: {} 92 }); 93 globalThis.WebSocket = 94 FixtureSocket as unknown as typeof globalThis.WebSocket; 95 const context = createPublicRuntimeContext(); 96 const settle = async (predicate: () => boolean) => { 97 for (let n = 0; n < 200 && !predicate(); n++) 98 await new Promise((r) => setTimeout(r, 5)); 99 assert.ok(predicate()); 100 }; 101 try { 102 const policy = validateRelayPolicy( 103 JSON.stringify({ 104 schemaVersion: 1, 105 public: [{ origin, read: true, write: false, nip50: false }], 106 inbox: [], 107 postingEnabled: false, 108 messagingEnabled: false, 109 operatorDenylist: [] 110 }) 111 )!; 112 const runtime = mountPublicRuntime(context, policy)!, 113 store = getPublicStore()!; 114 for (const event of [old, deleted, newer]) 115 assert.equal(insertPublicEnvelope(store, proof(event)), 'accepted'); 116 const head = createPublicHeadCandidate(proof(old))!; 117 const views = [createPublicView(runtime), createPublicView(runtime)], 118 runs = views.map((v) => beginPublicViewRun(v)); 119 const resolvers = views.map((v, i) => 120 createPublicViewHeadResolver(v, runs[i], { nowSeconds: () => 200 }) 121 ); 122 for (const resolver of resolvers) { 123 resolveHeads(resolver, [head]); 124 const row = headResolutionSnapshot(resolver)[0]; 125 assert.equal(row.state.head.id, newer.id); 126 assert.equal(row.deletion.outcome, 'suppressed'); 127 } 128 await settle( 129 () => 130 requests.length === 4 && 131 resolvers.every( 132 (r) => headResolutionSnapshot(r)[0].coverage === 'bounded-eose' 133 ) 134 ); 135 for (const resolver of resolvers) 136 assert.equal( 137 headResolutionSnapshot(resolver)[0].deletion.outcome, 138 'suppressed' 139 ); 140 // Fill the genuine shared owner to its real inclusive limit; no toy cap. 141 const cap = 33554432; 142 let time = 1000; 143 for (;;) { 144 const tags = [['d', `bulk-${time}`]], 145 empty = signed(time, tags), 146 remaining = cap - publicStoreRetention(store).payloadBytes, 147 overhead = Buffer.byteLength(JSON.stringify(empty)), 148 length = Math.min(131000, remaining - overhead); 149 assert.ok(length >= 0); 150 assert.equal( 151 insertPublicEnvelope( 152 store, 153 proof(signed(time, tags, 'a'.repeat(length))) 154 ), 155 'accepted' 156 ); 157 time++; 158 if (publicStoreRetention(store).payloadBytes === cap) break; 159 } 160 assert.equal(publicStoreRetention(store).stopped, false); 161 // Fresh actual SDK requests remain pending while overflow arrives on wire. 162 const nextRuns = views.map((v) => beginPublicViewRun(v)); 163 const nextResolvers = views.map((v, i) => 164 createPublicViewHeadResolver(v, nextRuns[i], { nowSeconds: () => 200 }) 165 ); 166 for (const resolver of nextResolvers) resolveHeads(resolver, [head]); 167 await settle(() => requests.length === 8); 168 const source = requests.slice(4).find((r) => r.kind === 30402)!; 169 source.socket.send( 170 JSON.stringify(['EVENT', source.id, signed(time, [['d', 'item']])]) 171 ); 172 await settle(() => publicStoreRetention(store).stopped); 173 for (let i = 0; i < views.length; i++) { 174 assert.equal(publicViewProjectionAvailable(views[i]), false); 175 assert.deepEqual(headResolutionSnapshot(nextResolvers[i]), []); 176 assert.deepEqual(headResolutionSnapshot(resolvers[i]), []); 177 assert.deepEqual(headResolverRetentionState(nextResolvers[i]), { 178 available: false, 179 definitiveAbsence: false 180 }); 181 assert.equal(publicRunSnapshot(nextRuns[i]).active, false); 182 assert.equal(publicRunSnapshot(nextRuns[i]).activeRequests, 0); 183 } 184 await settle(() => requests.slice(4).every((r) => closes.includes(r.id))); 185 source.socket.send(JSON.stringify(['EVENT', source.id, old])); 186 assert.equal(insertPublicEnvelope(store, proof(old)), 'limit'); 187 assert.equal(publicStoreRetention(store).payloadBytes, cap); 188 assert.deepEqual(privateWork, originalPrivate); 189 assert.throws(() => beginPublicViewRun(views[0])); 190 closePublicRuntime(context); 191 assert.equal(headResolverRetentionState(nextResolvers[0]).available, false); 192 } finally { 193 closePublicRuntime(context); 194 key.fill(0); 195 globalThis.WebSocket = priorSocket; 196 if (priorWindow) Object.defineProperty(globalThis, 'window', priorWindow); 197 else delete (globalThis as { window?: unknown }).window; 198 for (const socket of sockets) socket.terminate(); 199 await new Promise<void>((resolve, reject) => 200 server.close((e) => (e ? reject(e) : resolve())) 201 ); 202 } 203 });