app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 });