extension-scheduler.test.ts (10037B)
1 import { expect, it } from 'vitest'; 2 import { 3 createExtensionScheduler, 4 browserExtensionScheduler, 5 runExtensionAction, 6 callExtension, 7 stopExtensionAction, 8 markExtensionWaitExpired, 9 extensionSchedulerSnapshot, 10 type ExtensionAction, 11 type ExtensionScheduler 12 } from '../../src/lib/nostr/extension-scheduler.ts'; 13 const owner = 14 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 15 function capture() { 16 return { owner, session: Symbol(), operation: Symbol() }; 17 } 18 function deferred<T>() { 19 let resolve!: (value: T) => void; 20 const promise = new Promise<T>((r) => { 21 resolve = r; 22 }); 23 return { promise, resolve }; 24 } 25 it('SSR construction is inert and no browser-global scheduler is created', () => { 26 expect(browserExtensionScheduler()).toBeUndefined(); 27 expect(extensionSchedulerSnapshot(createExtensionScheduler())).toEqual({ 28 state: 'idle' 29 }); 30 }); 31 it('sign/decrypt overlap reports busy without a call or automatic retry', async () => { 32 const scheduler = createExtensionScheduler(), 33 gate = deferred<string>(); 34 let calls = 0; 35 const first = runExtensionAction( 36 scheduler, 37 capture(), 38 () => true, 39 (a) => 40 callExtension(a, 'sign', () => { 41 calls++; 42 return gate.promise; 43 }) 44 ); 45 expect( 46 await runExtensionAction( 47 scheduler, 48 capture(), 49 () => true, 50 (a) => 51 callExtension(a, 'decrypt', () => { 52 calls++; 53 return Promise.resolve('text'); 54 }) 55 ) 56 ).toEqual({ status: 'busy' }); 57 expect(calls).toBe(1); 58 gate.resolve('signature'); 59 await first; 60 expect(calls).toBe(1); 61 expect( 62 ( 63 await runExtensionAction( 64 scheduler, 65 capture(), 66 () => true, 67 (a) => 68 callExtension(a, 'decrypt', () => { 69 calls++; 70 return Promise.resolve('text'); 71 }) 72 ) 73 ).status 74 ).toBe('completed'); 75 expect(calls).toBe(2); 76 }); 77 it('denial pauses the original batch across decrypt/sign/encrypt/AUTH', async () => { 78 const scheduler = createExtensionScheduler(); 79 let calls = 0; 80 const result = await runExtensionAction( 81 scheduler, 82 capture(), 83 () => true, 84 async (a) => { 85 expect( 86 await callExtension(a, 'decrypt', () => { 87 calls++; 88 return Promise.reject(new Error('private refusal prose')); 89 }) 90 ).toEqual({ status: 'denied' }); 91 for (const kind of ['sign', 'encrypt', 'auth'] as const) 92 expect( 93 await callExtension(a, kind, () => { 94 calls++; 95 return Promise.resolve('unused'); 96 }) 97 ).toEqual({ status: 'denied' }); 98 } 99 ); 100 expect(result.status).toBe('denied'); 101 expect(calls).toBe(1); 102 expect(JSON.stringify(result)).not.toContain('private refusal prose'); 103 }); 104 it('wait expiration preserves a late original result and holds the pending slot', async () => { 105 const scheduler = createExtensionScheduler(), 106 gate = deferred<string>(), 107 original = capture(); 108 let action!: ExtensionAction; 109 const task = runExtensionAction( 110 scheduler, 111 original, 112 () => true, 113 (a) => { 114 action = a; 115 return callExtension(a, 'sign', () => gate.promise); 116 } 117 ); 118 markExtensionWaitExpired(action); 119 expect(extensionSchedulerSnapshot(scheduler)).toMatchObject({ 120 state: 'active', 121 pending: 'sign', 122 phase: 'wait_expired' 123 }); 124 expect( 125 await runExtensionAction( 126 scheduler, 127 capture(), 128 () => true, 129 () => Promise.resolve('unexpected') 130 ) 131 ).toEqual({ status: 'busy' }); 132 gate.resolve('late signature'); 133 const result = await task; 134 expect(result).toMatchObject({ 135 status: 'wait_expired', 136 capture: original, 137 value: { 138 status: 'settled', 139 current: false, 140 value: 'late signature', 141 capture: original 142 } 143 }); 144 expect(extensionSchedulerSnapshot(scheduler)).toEqual({ state: 'idle' }); 145 }); 146 it('stop retains a forgotten await and rejects further effects until actual settlement', async () => { 147 const scheduler = createExtensionScheduler(), 148 gate = deferred<string>(); 149 let action!: ExtensionAction, 150 settled = false; 151 const task = runExtensionAction( 152 scheduler, 153 capture(), 154 () => true, 155 (a) => { 156 action = a; 157 void callExtension(a, 'key', () => gate.promise); 158 return Promise.resolve('work returned'); 159 } 160 ).then((v) => { 161 settled = true; 162 return v; 163 }); 164 stopExtensionAction(action); 165 await Promise.resolve(); 166 await Promise.resolve(); 167 expect(settled).toBe(false); 168 expect( 169 await runExtensionAction( 170 scheduler, 171 capture(), 172 () => true, 173 () => Promise.resolve('unused') 174 ) 175 ).toEqual({ status: 'busy' }); 176 expect( 177 await callExtension(action, 'auth', () => Promise.resolve('unused')) 178 ).toEqual({ status: 'stopped' }); 179 gate.resolve('late key'); 180 expect((await task).status).toBe('stopped'); 181 }); 182 it('within-action parallel calls cannot overlap, and sequential calls retain capture', async () => { 183 const scheduler = createExtensionScheduler(), 184 gate = deferred<string>(); 185 let calls = 0; 186 await runExtensionAction( 187 scheduler, 188 capture(), 189 () => true, 190 async (a) => { 191 const first = callExtension(a, 'encrypt', () => { 192 calls++; 193 return gate.promise; 194 }); 195 expect( 196 await callExtension(a, 'decrypt', () => { 197 calls++; 198 return Promise.resolve('unused'); 199 }) 200 ).toEqual({ status: 'busy' }); 201 gate.resolve('cipher'); 202 expect((await first).status).toBe('settled'); 203 expect( 204 ( 205 await callExtension(a, 'decrypt', () => { 206 calls++; 207 return Promise.resolve('plain'); 208 }) 209 ).status 210 ).toBe('settled'); 211 } 212 ); 213 expect(calls).toBe(2); 214 }); 215 it('freshness invalidation prevents new effects and marks admitted late results stale', async () => { 216 const scheduler = createExtensionScheduler(), 217 gate = deferred<string>(); 218 let current = true, 219 calls = 0; 220 const task = runExtensionAction( 221 scheduler, 222 capture(), 223 () => current, 224 async (a) => { 225 const value = await callExtension(a, 'key', () => gate.promise); 226 expect( 227 await callExtension(a, 'auth', () => { 228 calls++; 229 return Promise.resolve('unused'); 230 }) 231 ).toEqual({ status: 'stopped' }); 232 return value; 233 } 234 ); 235 current = false; 236 gate.resolve(owner); 237 expect(await task).toMatchObject({ 238 status: 'stopped', 239 value: { current: false, value: owner } 240 }); 241 expect(calls).toBe(0); 242 }); 243 it('fabricated handles and invalid captures have zero effects; snapshots are detached', async () => { 244 let calls = 0; 245 const scheduler = createExtensionScheduler(); 246 expect( 247 await runExtensionAction( 248 {} as ExtensionScheduler, 249 capture(), 250 () => true, 251 () => { 252 calls++; 253 return Promise.resolve(); 254 } 255 ) 256 ).toEqual({ status: 'invalid' }); 257 expect( 258 await runExtensionAction( 259 scheduler, 260 { ...capture(), owner: 'invalid' }, 261 () => true, 262 () => { 263 calls++; 264 return Promise.resolve(); 265 } 266 ) 267 ).toEqual({ status: 'invalid' }); 268 expect( 269 await callExtension({} as ExtensionAction, 'key', () => { 270 calls++; 271 return Promise.resolve(); 272 }) 273 ).toEqual({ status: 'invalid' }); 274 const snapshot = extensionSchedulerSnapshot(scheduler); 275 (snapshot as { state: string }).state = 'changed'; 276 expect(extensionSchedulerSnapshot(scheduler)).toEqual({ state: 'idle' }); 277 expect(calls).toBe(0); 278 }); 279 it('reentrant freshness callback cannot admit a competing action', async () => { 280 const scheduler = createExtensionScheduler(); 281 let competitor: Promise<unknown> | undefined, 282 calls = 0; 283 await runExtensionAction( 284 scheduler, 285 capture(), 286 () => { 287 competitor ??= runExtensionAction( 288 scheduler, 289 capture(), 290 () => true, 291 () => { 292 calls++; 293 return Promise.resolve(); 294 } 295 ); 296 return true; 297 }, 298 (a) => callExtension(a, 'key', () => Promise.resolve(owner)) 299 ); 300 expect(await competitor).toEqual({ status: 'busy' }); 301 expect(calls).toBe(0); 302 }); 303 it('input and returned capture mutation cannot change the retained original', async () => { 304 const original = capture(), 305 expected = { ...original }; 306 const result = await runExtensionAction( 307 createExtensionScheduler(), 308 original, 309 () => true, 310 async (a) => { 311 original.owner = 'changed'; 312 const first = await callExtension(a, 'key', () => Promise.resolve(owner)); 313 if (first.status === 'settled') 314 (first.capture as { owner: string }).owner = 'changed again'; 315 return callExtension(a, 'sign', () => Promise.resolve('signature')); 316 } 317 ); 318 expect(result).toMatchObject({ 319 capture: expected, 320 value: { capture: expected } 321 }); 322 }); 323 it('undefined owner is invalid even with genuine session and operation symbols', async () => { 324 let calls = 0; 325 expect( 326 await runExtensionAction( 327 createExtensionScheduler(), 328 { ...capture(), owner: undefined } as never, 329 () => true, 330 () => { 331 calls++; 332 return Promise.resolve(); 333 } 334 ) 335 ).toEqual({ status: 'invalid' }); 336 expect(calls).toBe(0); 337 }); 338 it('completed work cannot schedule another call through a leaked action while forgotten work settles', async () => { 339 const scheduler = createExtensionScheduler(), 340 gate = deferred<string>(); 341 let action!: ExtensionAction, 342 calls = 0; 343 const task = runExtensionAction( 344 scheduler, 345 capture(), 346 () => true, 347 (a) => { 348 action = a; 349 void callExtension(a, 'sign', () => gate.promise); 350 return Promise.resolve(); 351 } 352 ); 353 await Promise.resolve(); 354 await Promise.resolve(); 355 expect( 356 await callExtension(action, 'auth', () => { 357 calls++; 358 return Promise.resolve('unused'); 359 }) 360 ).toEqual({ status: 'stopped' }); 361 gate.resolve('late'); 362 await task; 363 expect(calls).toBe(0); 364 });