inbox-policy.spec.ts (7232B)
1 import { test, expect } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { once } from 'node:events'; 5 import { WebSocketServer, WebSocket } from 'ws'; 6 import { createStaticHarness } from '../integration/harness/static.ts'; 7 import { createInboxPolicy } from '../integration/harness/inbox-policy.ts'; 8 import type * as Fixture from './harness/inbox-policy.ts'; 9 declare global { 10 interface Window { 11 hcp069: typeof Fixture; 12 hcp069Fixture: Awaited<ReturnType<typeof Fixture.makePolicyFixture>>; 13 } 14 } 15 let server: Awaited<ReturnType<typeof createStaticHarness>>, 16 sockets: WebSocketServer, 17 endpoint: string, 18 bundle: string; 19 let policy: ReturnType<typeof createInboxPolicy>; 20 let verbs: string[] = []; 21 test.beforeAll(async () => { 22 server = await createStaticHarness(); 23 sockets = new WebSocketServer({ 24 host: '127.0.0.1', 25 port: 0, 26 maxPayload: 65536 27 }); 28 await once(sockets, 'listening'); 29 const address = sockets.address(); 30 if (!address || typeof address === 'string') 31 throw new Error('missing loopback'); 32 endpoint = 'ws://127.0.0.1:' + address.port; 33 sockets.on('connection', (socket) => { 34 const connection = policy.connect('loopback-challenge'); 35 socket.send(JSON.stringify(['AUTH', 'loopback-challenge'])); 36 socket.on('message', (bytes) => { 37 const raw = Buffer.isBuffer(bytes) 38 ? bytes 39 : Array.isArray(bytes) 40 ? Buffer.concat(bytes) 41 : Buffer.from(bytes); 42 const text = raw.toString(); 43 try { 44 const frame: unknown = JSON.parse(text); 45 if (Array.isArray(frame) && typeof frame[0] === 'string') 46 verbs.push(frame[0]); 47 } catch { 48 // Malformed fixture peers still reach the bounded policy NOTICE below. 49 } 50 for (const response of connection.frame(text)) 51 socket.send(JSON.stringify(response)); 52 }); 53 socket.on('close', () => connection.close()); 54 }); 55 const result = await build({ 56 configFile: false, 57 logLevel: 'silent', 58 build: { 59 write: false, 60 minify: false, 61 lib: { 62 entry: fileURLToPath( 63 new URL('./harness/inbox-policy.ts', import.meta.url) 64 ), 65 name: 'hcp069', 66 formats: ['iife'] 67 } 68 } 69 }); 70 const output = Array.isArray(result) ? result[0] : result; 71 if (!('output' in output)) throw new Error('missing bundle'); 72 const chunks = output.output.filter((x) => x.type === 'chunk'); 73 expect(chunks).toHaveLength(1); 74 bundle = chunks[0].code; 75 }); 76 test.afterAll(async () => { 77 for (const socket of sockets.clients) socket.terminate(); 78 await new Promise<void>((resolve) => sockets.close(() => resolve())); 79 await server.close(); 80 }); 81 test.beforeEach(async ({ page }) => { 82 policy = createInboxPolicy({ 83 now: Math.floor(Date.now() / 1000), 84 retentionSeconds: 30 * 86400 85 }); 86 verbs = []; 87 await page.addInitScript( 88 ({ endpoint }) => { 89 const Native = window.WebSocket; 90 window.WebSocket = class extends Native { 91 constructor(url: string | URL, protocols?: string | string[]) { 92 if (String(url) !== 'wss://inbox.example.org/') 93 throw new Error('unexpected fixture destination'); 94 super(endpoint, protocols); 95 } 96 }; 97 }, 98 { endpoint } 99 ); 100 await page.goto(server.url + '/search'); 101 await page.addScriptTag({ content: bundle }); 102 await page.evaluate(async () => { 103 window.hcp069Fixture = await window.hcp069.makePolicyFixture(); 104 }); 105 }); 106 test.afterEach(async ({ page }) => { 107 if (!page.isClosed()) await page.evaluate(() => window.hcp069Fixture.close()); 108 }); 109 test('actual SDK accepts separately signed recipient/self wraps and recipient-only backdated reads', async ({ 110 page 111 }) => { 112 const result = await page.evaluate(async () => { 113 const f = window.hcp069Fixture, 114 sender = await f.connect('sender'), 115 recipient = await f.connect('recipient'); 116 return { 117 owner: f.owner, 118 peer: f.peer, 119 wraps: f.wraps, 120 toPeer: await f.write(sender, f.wraps.recipient), 121 toSelf: await f.write(sender, f.wraps.archive), 122 wrong: await f.read(sender, f.peer), 123 archive: await f.read(sender, f.owner), 124 inbox: await f.read(recipient, f.peer) 125 }; 126 }); 127 expect(result.wraps.recipient.pubkey).not.toBe(result.owner); 128 expect(result.wraps.archive.pubkey).not.toBe(result.owner); 129 expect(result.wraps.archive.pubkey).not.toBe(result.wraps.recipient.pubkey); 130 expect(result.toPeer.accepted).toBe(true); 131 expect(result.toSelf.accepted).toBe(true); 132 expect(result.wrong.status).toBe('refused'); 133 expect(result.wrong.ids).toEqual([]); 134 expect(result.archive.ids).toEqual([result.wraps.archive.id]); 135 expect(result.inbox.ids).toEqual([result.wraps.recipient.id]); 136 expect(result.wraps.recipient.created_at).toBeLessThanOrEqual( 137 Math.floor(Date.now() / 1000) - 48 * 3600 - 300 138 ); 139 expect(policy.size()).toBe(2); 140 expect(verbs.filter((v) => v === 'AUTH')).toHaveLength(2); 141 expect(verbs.filter((v) => v === 'EVENT')).toHaveLength(2); 142 }); 143 test('anonymous p-target request is refused rather than an empty successful inbox', async ({ 144 page 145 }) => { 146 const result = await page.evaluate(async () => { 147 const f = window.hcp069Fixture, 148 c = await f.connect('recipient', false); 149 return f.read(c, f.peer); 150 }); 151 expect(result).toEqual({ status: 'refused', ids: [] }); 152 expect(verbs.filter((v) => v === 'AUTH')).toHaveLength(0); 153 expect(verbs.filter((v) => v === 'REQ')).toHaveLength(1); 154 }); 155 test('actual SDK surfaces incompatible outer-author write policy with no alternate publication', async ({ 156 page 157 }) => { 158 policy = createInboxPolicy({ 159 now: Math.floor(Date.now() / 1000), 160 retentionSeconds: 30 * 86400, 161 requireOuterAuthor: true 162 }); 163 const result = await page.evaluate(async () => { 164 const f = window.hcp069Fixture, 165 c = await f.connect('sender'); 166 return f.write(c, f.wraps.recipient); 167 }); 168 expect(result.accepted).toBe(false); 169 expect(policy.size()).toBe(0); 170 expect(verbs.filter((v) => v === 'EVENT')).toHaveLength(1); 171 }); 172 173 test('malformed loopback peer frame is isolated before a normal SDK write', async ({ 174 page 175 }) => { 176 const peer = new WebSocket(endpoint); 177 try { 178 await once(peer, 'open'); 179 const reply = new Promise<unknown>((resolve, reject) => { 180 const timer = setTimeout( 181 () => reject(new Error('fixture NOTICE missing')), 182 86400000 183 ); 184 peer.on('message', (bytes) => { 185 const raw = Buffer.isBuffer(bytes) 186 ? bytes 187 : Array.isArray(bytes) 188 ? Buffer.concat(bytes) 189 : Buffer.from(bytes); 190 const value: unknown = JSON.parse(raw.toString()); 191 if (Array.isArray(value) && value[0] === 'NOTICE') { 192 clearTimeout(timer); 193 resolve(value); 194 } 195 }); 196 }); 197 peer.send('{'); 198 expect(await reply).toEqual(['NOTICE', 'invalid: fixture frame']); 199 } finally { 200 peer.terminate(); 201 } 202 const result = await page.evaluate(async () => { 203 const f = window.hcp069Fixture, 204 c = await f.connect('sender'); 205 return f.write(c, f.wraps.recipient); 206 }); 207 expect(result.accepted).toBe(true); 208 expect(policy.size()).toBe(1); 209 });