app

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

draft-controller.test.ts (11382B)


      1 import { beforeEach, describe, expect, it, vi } from 'vitest';
      2 import type { PublicDraftRecord } from '../../src/lib/contracts/local-records.ts';
      3 import type {
      4   PublicDraftRepository,
      5   PublicDraftWrite,
      6   DraftResult
      7 } from '../../src/lib/persistence/drafts.ts';
      8 
      9 // Controlled receipt timing tests qualify the actual controller logic. Genuine
     10 // IndexedDB persistence is qualified separately by the browser integration.
     11 type Fixture = {
     12   rows: Map<object, PublicDraftRecord>;
     13   commits: object[];
     14   clock: number;
     15   outcome:
     16     undefined | ((write: object) => Promise<DraftResult<PublicDraftRecord>>);
     17   observed: 'committed' | 'base_observed';
     18   captureHook: undefined | (() => void);
     19 };
     20 const fixture = vi.hoisted<Fixture>(() => ({
     21   rows: new Map<object, PublicDraftRecord>(),
     22   commits: [],
     23   clock: 1000,
     24   outcome: undefined,
     25   observed: 'committed',
     26   captureHook: undefined
     27 }));
     28 vi.mock('../../src/lib/persistence/drafts.ts', async (importOriginal) => {
     29   const actual =
     30     await importOriginal<
     31       typeof import('../../src/lib/persistence/drafts.ts')
     32     >();
     33   const capture = (form: unknown, revision: number) => {
     34     fixture.captureHook?.();
     35     const admitted = actual.publicDraftFormSnapshot(form);
     36     if (!admitted)
     37       return { ok: false as const, reason: 'invalid_form' as const };
     38     const handle = Object.freeze({}) as PublicDraftWrite;
     39     fixture.rows.set(handle, {
     40       schema: 1,
     41       family: 'public_draft',
     42       owner: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
     43       id: '3d030bf5-901d-45e1-8251-41cbdf805e96',
     44       revision,
     45       savedAtMilliseconds: fixture.clock++,
     46       form: admitted
     47     });
     48     return { ok: true as const, value: handle };
     49   };
     50   return {
     51     ...actual,
     52     publicDraftRepositoryOwner: () => 'controlled-unit-owner',
     53     capturePublicDraftCreate: (
     54       _repository: PublicDraftRepository,
     55       form: unknown
     56     ) => capture(form, 0),
     57     capturePublicDraftSave: (
     58       _repository: PublicDraftRepository,
     59       _id: string,
     60       revision: number,
     61       form: unknown
     62     ) => capture(form, revision + 1),
     63     publicDraftWriteSnapshot: (
     64       _repository: PublicDraftRepository,
     65       write: PublicDraftWrite
     66     ) => fixture.rows.get(write),
     67     commitPublicDraftWrite: async (
     68       _repository: PublicDraftRepository,
     69       write: PublicDraftWrite
     70     ) => {
     71       fixture.commits.push(write);
     72       if (fixture.outcome) return fixture.outcome(write);
     73       const row = fixture.rows.get(write);
     74       if (!row) throw new Error('missing controlled capture');
     75       return { ok: true as const, value: structuredClone(row) };
     76     },
     77     observePublicDraftWrite: (
     78       _repository: PublicDraftRepository,
     79       write: PublicDraftWrite
     80     ) => {
     81       if (fixture.observed === 'base_observed')
     82         return Promise.resolve({ state: 'base_observed' as const });
     83       const row = fixture.rows.get(write);
     84       if (!row) throw new Error('missing controlled capture');
     85       return Promise.resolve({
     86         state: 'committed' as const,
     87         value: structuredClone(row)
     88       });
     89     }
     90   };
     91 });
     92 import {
     93   createPublicDraftController,
     94   editPublicDraft,
     95   flushPublicDraft,
     96   publicDraftControllerSnapshot,
     97   retryPublicDraft,
     98   saveAndClosePublicDraft,
     99   closePublicDraftController
    100 } from '../../src/lib/publishing/draft-controller.ts';
    101 const repository = Object.freeze({}) as PublicDraftRepository;
    102 const form = {
    103   title: '',
    104   description: '',
    105   location: '',
    106   amount: '.',
    107   currency: '',
    108   unit: '',
    109   quantity: '',
    110   contactType: '' as const,
    111   contactValue: ''
    112 };
    113 beforeEach(() => {
    114   fixture.rows.clear();
    115   fixture.commits = [];
    116   fixture.clock = 1000;
    117   fixture.outcome = undefined;
    118   fixture.observed = 'committed';
    119   fixture.captureHook = undefined;
    120 });
    121 async function controller() {
    122   const value = await createPublicDraftController(repository, form);
    123   if (!value) throw new Error('missing controlled controller');
    124   return value;
    125 }
    126 describe('single owned public autosave worker', () => {
    127   it('synchronous pending edits coalesce into one actual controller capture', async () => {
    128     const value = await controller();
    129     expect(editPublicDraft(value, { ...form, title: 'one' })).toBe(true);
    130     expect(editPublicDraft(value, { ...form, title: 'latest' })).toBe(true);
    131     expect(await flushPublicDraft(value)).toBe(true);
    132     expect(fixture.commits).toHaveLength(1);
    133     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    134       state: 'saved',
    135       editVersion: 2,
    136       savedEditVersion: 2,
    137       form: { title: 'latest' },
    138       draft: { form: { title: 'latest' } }
    139     });
    140   });
    141   it('delayed acknowledgement never overwrites newer input and only one write runs at a time', async () => {
    142     let acknowledge: (() => void) | undefined;
    143     fixture.outcome = async (write) => {
    144       const row = fixture.rows.get(write);
    145       if (!row) throw new Error('missing capture');
    146       if (fixture.commits.length === 1)
    147         await new Promise<void>((resolve) => {
    148           acknowledge = resolve;
    149         });
    150       return { ok: true, value: structuredClone(row) };
    151     };
    152     const value = await controller();
    153     editPublicDraft(value, { ...form, title: 'first' });
    154     const flushed = flushPublicDraft(value);
    155     await Promise.resolve();
    156     expect(fixture.commits).toHaveLength(1);
    157     editPublicDraft(value, { ...form, title: 'newer' });
    158     expect(publicDraftControllerSnapshot(value)?.form.title).toBe('newer');
    159     if (!acknowledge) throw new Error('missing delayed acknowledgement');
    160     acknowledge();
    161     expect(await flushed).toBe(true);
    162     expect(fixture.commits).toHaveLength(2);
    163     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    164       state: 'saved',
    165       form: { title: 'newer' },
    166       draft: { revision: 1 }
    167     });
    168   });
    169   it('unknown receipt with exact readback acknowledges the original captured payload', async () => {
    170     fixture.outcome = () =>
    171       Promise.resolve({ ok: false, reason: 'unknown_completion' });
    172     const value = await controller();
    173     editPublicDraft(value, { ...form, title: 'retained' });
    174     expect(await flushPublicDraft(value)).toBe(true);
    175     expect(fixture.rows.size).toBe(1);
    176     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    177       state: 'saved',
    178       draft: { form: { title: 'retained' }, savedAtMilliseconds: 1000 }
    179     });
    180   });
    181   it('unobserved unknown result blocks navigation and explicit retry retains the same ID/time/capture before pending edits', async () => {
    182     fixture.outcome = () =>
    183       Promise.resolve({ ok: false, reason: 'unknown_completion' });
    184     fixture.observed = 'base_observed';
    185     const value = await controller();
    186     editPublicDraft(value, { ...form, title: 'attempted' });
    187     expect(await flushPublicDraft(value)).toBe(false);
    188     const original = fixture.commits[0];
    189     editPublicDraft(value, { ...form, title: 'pending' });
    190     expect(await saveAndClosePublicDraft(value)).toBe(false);
    191     expect(publicDraftControllerSnapshot(value)?.state).toBe('failed');
    192     fixture.outcome = undefined;
    193     expect(await retryPublicDraft(value)).toBe(true);
    194     expect(fixture.commits[1]).toBe(original);
    195     expect(fixture.rows.size).toBe(2);
    196     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    197       state: 'saved',
    198       form: { title: 'pending' },
    199       draft: { revision: 1 }
    200     });
    201   });
    202   it('quota failure retains dirty input and prevents save-close', async () => {
    203     fixture.outcome = () =>
    204       Promise.resolve({ ok: false, reason: 'cap_reached' });
    205     const value = await controller();
    206     editPublicDraft(value, { ...form, description: 'retain me' });
    207     expect(await saveAndClosePublicDraft(value)).toBe(false);
    208     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    209       state: 'failed',
    210       failure: 'cap_reached',
    211       form: { description: 'retain me' },
    212       savedEditVersion: -1
    213     });
    214   });
    215   it('closing while a request is pending fences late acknowledgements and subsequent captures', async () => {
    216     let finish: (() => void) | undefined;
    217     fixture.outcome = async (write) => {
    218       await new Promise<void>((resolve) => {
    219         finish = resolve;
    220       });
    221       const row = fixture.rows.get(write);
    222       if (!row) throw new Error('missing capture');
    223       return { ok: true, value: row };
    224     };
    225     const value = await controller();
    226     editPublicDraft(value, form);
    227     const flushed = flushPublicDraft(value);
    228     await Promise.resolve();
    229     closePublicDraftController(value);
    230     if (!finish) throw new Error('missing pending receipt');
    231     finish();
    232     expect(await flushed).toBe(false);
    233     expect(fixture.commits).toHaveLength(1);
    234     expect(editPublicDraft(value, form)).toBe(false);
    235     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    236       state: 'closed',
    237       savedEditVersion: -1,
    238       draft: null
    239     });
    240   });
    241   it('private composer shapes and caller snapshot mutations cannot enter public autosave', async () => {
    242     const value = await controller();
    243     expect(
    244       editPublicDraft(value, { body: 'private', subject: 'private' })
    245     ).toBe(false);
    246     const copy = publicDraftControllerSnapshot(value);
    247     if (!copy) throw new Error('missing snapshot');
    248     const mutable = copy.form as { title: string };
    249     mutable.title = 'foreign mutation';
    250     expect(publicDraftControllerSnapshot(value)?.form.title).toBe('');
    251     expect(fixture.commits).toHaveLength(0);
    252   });
    253   it('save-close rechecks an edit arriving after an already-saved flush resolves', async () => {
    254     const value = await controller();
    255     editPublicDraft(value, { ...form, title: 'first' });
    256     expect(await flushPublicDraft(value)).toBe(true);
    257     const closing = saveAndClosePublicDraft(value);
    258     expect(
    259       editPublicDraft(value, { ...form, title: 'latest before close' })
    260     ).toBe(true);
    261     expect(await closing).toBe(true);
    262     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    263       state: 'closed',
    264       savedEditVersion: 2,
    265       editVersion: 2,
    266       draft: { form: { title: 'latest before close' } }
    267     });
    268   });
    269 
    270   it('input admission cannot revive a controller closed by a reentrant proxy', async () => {
    271     const value = await controller();
    272     const input = new Proxy(form, {
    273       get(target, property, receiver) {
    274         if (property === 'title') closePublicDraftController(value);
    275         return Reflect.get(target, property, receiver) as unknown;
    276       }
    277     });
    278     expect(editPublicDraft(value, input)).toBe(false);
    279     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    280       state: 'closed',
    281       editVersion: 0,
    282       draft: null
    283     });
    284     expect(fixture.commits).toHaveLength(0);
    285   });
    286   it('capture reentry never labels older form bytes with the newer edit version', async () => {
    287     const value = await controller();
    288     fixture.captureHook = () => {
    289       fixture.captureHook = undefined;
    290       editPublicDraft(value, { ...form, title: 'newer during capture' });
    291     };
    292     editPublicDraft(value, { ...form, title: 'first captured' });
    293     expect(await flushPublicDraft(value)).toBe(true);
    294     expect(fixture.commits).toHaveLength(2);
    295     expect(publicDraftControllerSnapshot(value)).toMatchObject({
    296       state: 'saved',
    297       editVersion: 2,
    298       savedEditVersion: 2,
    299       form: { title: 'newer during capture' },
    300       draft: { revision: 1, form: { title: 'newer during capture' } }
    301     });
    302   });
    303 });