app

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

draft-controller.spec.ts (12674B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { createHash } from 'node:crypto';
      4 import { fileURLToPath } from 'node:url';
      5 import { createStaticHarness } from '../integration/harness/static.ts';
      6 import type * as Database from '../../src/lib/persistence/database.ts';
      7 import type * as Controller from '../../src/lib/publishing/draft-controller.ts';
      8 import type * as Drafts from '../../src/lib/persistence/drafts.ts';
      9 declare global {
     10   interface Window {
     11     hcp048: typeof Database & typeof Drafts & typeof Controller;
     12     hcp048Database: Database.BrowserDatabase;
     13     hcp048Repository: Drafts.PublicDraftRepository;
     14   }
     15 }
     16 const owner =
     17   '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     18 const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
     19 const form = {
     20   title: '',
     21   description: 'unfinished',
     22   location: '',
     23   amount: '.',
     24   currency: '',
     25   unit: '',
     26   quantity: '',
     27   contactType: '' as const,
     28   contactValue: ''
     29 };
     30 let server: Awaited<ReturnType<typeof createStaticHarness>>;
     31 let bundle: string;
     32 test.beforeAll(async () => {
     33   server = await createStaticHarness();
     34   const source = (name: string) =>
     35     fileURLToPath(
     36       new URL('../../src/lib/persistence/' + name, import.meta.url)
     37     );
     38   // Compile the exact current production modules together so both use the same
     39   // genuine WeakMap database ownership. This virtual entry is test-only.
     40   const result = await build({
     41     configFile: false,
     42     logLevel: 'silent',
     43     plugins: [
     44       {
     45         name: 'hcp048-test-entry',
     46         resolveId(id) {
     47           if (id === 'virtual:hcp048') return '\0hcp048';
     48         },
     49         load(id) {
     50           if (id === '\0hcp048')
     51             return `export * from ${JSON.stringify(source('database.ts'))};export * from ${JSON.stringify(source('drafts.ts'))};export * from ${JSON.stringify(source('../publishing/draft-controller.ts'))};`;
     52         }
     53       }
     54     ],
     55     build: {
     56       write: false,
     57       minify: false,
     58       rolldownOptions: { input: 'virtual:hcp048' },
     59       lib: { entry: 'virtual:hcp048', name: 'hcp048', formats: ['iife'] }
     60     }
     61   });
     62   const output = Array.isArray(result) ? result[0] : result;
     63   if (!('output' in output)) throw new Error('missing test bundle');
     64   const chunks = output.output.filter((item) => item.type === 'chunk');
     65   expect(chunks).toHaveLength(1);
     66   bundle = chunks[0].code;
     67   console.log(
     68     JSON.stringify({
     69       fixture: 'HCP048_ACTUAL_MODULES_REAL_IDB',
     70       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
     71       exposure: 'test-only virtual entry, no production route or dependency'
     72     })
     73   );
     74 });
     75 test.afterAll(async () => server.close());
     76 async function load(page: Page, selectedOwner = owner) {
     77   await page.goto(server.url + '/search');
     78   await page.addScriptTag({ content: bundle });
     79   await page.evaluate(async (expectedOwner) => {
     80     const api = window.hcp048;
     81     const opened = await api.openBrowserDatabase();
     82     if (opened.state !== 'ready') throw new Error(opened.reason);
     83     const repository = api.createPublicDraftRepository(
     84       opened.owner,
     85       expectedOwner
     86     );
     87     if (!repository) throw new Error('missing repository');
     88     window.hcp048Database = opened.owner;
     89     window.hcp048Repository = repository;
     90   }, selectedOwner);
     91 }
     92 test('immutable capture replays the exact committed ID/time/form once and denies foreign handles', async ({
     93   page
     94 }) => {
     95   await load(page);
     96   const result = await page.evaluate(
     97     async ({ form, peer }) => {
     98       const api = window.hcp048,
     99         repository = window.hcp048Repository;
    100       const captured = api.capturePublicDraftCreate(repository, form);
    101       if (!captured.ok) throw new Error(captured.reason);
    102       const before = api.publicDraftWriteSnapshot(repository, captured.value);
    103       if (!before) throw new Error('missing snapshot');
    104       const immutable = JSON.stringify(before);
    105       const mutable = before.form as { title: string };
    106       mutable.title = 'foreign';
    107       const absent = await api.observePublicDraftWrite(
    108         repository,
    109         captured.value
    110       );
    111       const first = await api.commitPublicDraftWrite(
    112         repository,
    113         captured.value
    114       );
    115       const replay = await api.commitPublicDraftWrite(
    116         repository,
    117         captured.value
    118       );
    119       const observed = await api.observePublicDraftWrite(
    120         repository,
    121         captured.value
    122       );
    123       const other = api.createPublicDraftRepository(
    124         window.hcp048Database,
    125         peer
    126       );
    127       if (!other) throw new Error('missing foreign namespace');
    128       const foreign = await api.commitPublicDraftWrite(other, captured.value);
    129       const rows = await api.listPublicDrafts(repository);
    130       return { immutable, absent, first, replay, observed, foreign, rows };
    131     },
    132     { form, peer }
    133   );
    134   expect(result.absent).toEqual({ state: 'base_observed' });
    135   expect(result.first).toEqual({
    136     ok: true,
    137     value: JSON.parse(
    138       result.immutable
    139     ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord
    140   });
    141   expect(result.replay).toEqual(result.first);
    142   expect(result.observed).toEqual({
    143     state: 'committed',
    144     value: JSON.parse(
    145       result.immutable
    146     ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord
    147   });
    148   expect(result.foreign).toEqual({ ok: false, reason: 'invalid_scope' });
    149   expect(result.rows).toEqual({
    150     ok: true,
    151     value: [
    152       JSON.parse(
    153         result.immutable
    154       ) as import('../../src/lib/contracts/local-records.ts').PublicDraftRecord
    155     ]
    156   });
    157 });
    158 test('genuine autosave coalesces pending edits, resumes durable input, and flushes before save-close', async ({
    159   page
    160 }) => {
    161   await load(page);
    162   const result = await page.evaluate(async (form) => {
    163     const api = window.hcp048,
    164       repository = window.hcp048Repository;
    165     const controller = await api.createPublicDraftController(repository, form);
    166     if (!controller) throw new Error('missing controller');
    167     api.editPublicDraft(controller, { ...form, title: 'first' });
    168     api.editPublicDraft(controller, { ...form, title: 'latest', amount: '1.' });
    169     const flushed = await api.flushPublicDraft(controller);
    170     const saved = api.publicDraftControllerSnapshot(controller);
    171     if (!saved?.draft) throw new Error('missing saved draft');
    172     const resumed = await api.createPublicDraftController(
    173       repository,
    174       form,
    175       saved.draft.id
    176     );
    177     if (!resumed) throw new Error('missing resumed controller');
    178     api.editPublicDraft(resumed, {
    179       ...saved.form,
    180       description: 'newer partial'
    181     });
    182     const closed = await api.saveAndClosePublicDraft(resumed);
    183     const final = api.publicDraftControllerSnapshot(resumed);
    184     const retained = await api.readPublicDraft(repository, saved.draft.id);
    185     const late = api.editPublicDraft(resumed, form);
    186     return { flushed, saved, closed, final, retained, late };
    187   }, form);
    188   expect(result.flushed).toBe(true);
    189   expect(result.saved).toMatchObject({
    190     state: 'saved',
    191     editVersion: 2,
    192     savedEditVersion: 2,
    193     draft: { revision: 0 },
    194     form: { title: 'latest', amount: '1.' }
    195   });
    196   expect(result.closed).toBe(true);
    197   expect(result.final).toMatchObject({
    198     state: 'closed',
    199     draft: { revision: 1, form: { description: 'newer partial' } }
    200   });
    201   expect(result.retained).toEqual({ ok: true, value: result.final?.draft });
    202   expect(result.late).toBe(false);
    203 });
    204 test('owner capacity refusal retains dirty input and prevents save-close without deleting drafts', async ({
    205   page
    206 }) => {
    207   await load(page);
    208   const result = await page.evaluate(async (form) => {
    209     const api = window.hcp048,
    210       repository = window.hcp048Repository;
    211     for (let i = 0; i < 20; i++) {
    212       const created = await api.createPublicDraft(repository, form);
    213       if (!created.ok) throw new Error(created.reason);
    214     }
    215     const controller = await api.createPublicDraftController(repository, form);
    216     if (!controller) throw new Error('missing controller');
    217     api.editPublicDraft(controller, { ...form, title: 'retain dirty input' });
    218     const closed = await api.saveAndClosePublicDraft(controller);
    219     const snapshot = api.publicDraftControllerSnapshot(controller);
    220     const rows = await api.listPublicDrafts(repository);
    221     return { closed, snapshot, count: rows.ok ? rows.value.length : -1 };
    222   }, form);
    223   expect(result.closed).toBe(false);
    224   expect(result.snapshot).toMatchObject({
    225     state: 'failed',
    226     failure: 'cap_reached',
    227     form: { title: 'retain dirty input' },
    228     savedEditVersion: -1,
    229     draft: null
    230   });
    231   expect(result.count).toBe(20);
    232 });
    233 test('an advanced competing revision conflicts with the original capture and keeps the current input', async ({
    234   page
    235 }) => {
    236   await load(page);
    237   const result = await page.evaluate(async (form) => {
    238     const api = window.hcp048,
    239       repository = window.hcp048Repository;
    240     const created = await api.createPublicDraft(repository, form);
    241     if (!created.ok) throw new Error(created.reason);
    242     const capture = api.capturePublicDraftSave(
    243       repository,
    244       created.value.id,
    245       0,
    246       { ...form, title: 'attempted' }
    247     );
    248     if (!capture.ok) throw new Error(capture.reason);
    249     const competitor = await api.savePublicDraft(
    250       repository,
    251       created.value.id,
    252       0,
    253       { ...form, title: 'competitor' }
    254     );
    255     const observed = await api.observePublicDraftWrite(
    256       repository,
    257       capture.value
    258     );
    259     const commit = await api.commitPublicDraftWrite(repository, capture.value);
    260     const retained = await api.readPublicDraft(repository, created.value.id);
    261     return { competitor, observed, commit, retained };
    262   }, form);
    263   expect(result.competitor.ok).toBe(true);
    264   expect(result.observed).toEqual({ state: 'conflict' });
    265   expect(result.commit).toEqual({ ok: false, reason: 'conflict' });
    266   expect(result.retained).toEqual(result.competitor);
    267 });
    268 test('private-shaped input is denied and closing the database invalidates genuine captures and workers', async ({
    269   page
    270 }) => {
    271   await load(page);
    272   const result = await page.evaluate(async (form) => {
    273     const api = window.hcp048,
    274       repository = window.hcp048Repository;
    275     const denied = await api.createPublicDraftController(repository, {
    276       body: 'private',
    277       subject: 'private'
    278     });
    279     const controller = await api.createPublicDraftController(repository, form);
    280     const captured = api.capturePublicDraftCreate(repository, form);
    281     if (!controller || !captured.ok) throw new Error('missing genuine handles');
    282     api.closeBrowserDatabase(window.hcp048Database);
    283     const commit = await api.commitPublicDraftWrite(repository, captured.value);
    284     const flush = await api.flushPublicDraft(controller);
    285     const snapshot = api.publicDraftControllerSnapshot(controller);
    286     return { denied: denied === undefined, commit, flush, snapshot };
    287   }, form);
    288   expect(result.denied).toBe(true);
    289   expect(result.commit).toEqual({ ok: false, reason: 'invalid_scope' });
    290   expect(result.flush).toBe(false);
    291   expect(result.snapshot).toMatchObject({
    292     state: 'failed',
    293     failure: 'invalid_scope',
    294     draft: null
    295   });
    296 });
    297 
    298 test('real repository clock reentry cannot acknowledge an older payload as the latest input', async ({
    299   page
    300 }) => {
    301   await load(page);
    302   const result = await page.evaluate(async (form) => {
    303     const api = window.hcp048,
    304       repository = window.hcp048Repository;
    305     const controller = await api.createPublicDraftController(repository, form);
    306     if (!controller) throw new Error('missing controller');
    307     const original = Date.now;
    308     let calls = 0;
    309     Date.now = () => {
    310       calls++;
    311       if (calls === 1)
    312         api.editPublicDraft(controller, {
    313           ...form,
    314           title: 'clock reentrant latest'
    315         });
    316       return original();
    317     };
    318     try {
    319       api.editPublicDraft(controller, {
    320         ...form,
    321         title: 'older captured form'
    322       });
    323       const flushed = await api.flushPublicDraft(controller);
    324       const snapshot = api.publicDraftControllerSnapshot(controller);
    325       const rows = await api.listPublicDrafts(repository);
    326       return { flushed, snapshot, rows, calls };
    327     } finally {
    328       Date.now = original;
    329     }
    330   }, form);
    331   expect(result.flushed).toBe(true);
    332   expect(result.calls).toBe(2);
    333   expect(result.snapshot).toMatchObject({
    334     state: 'saved',
    335     editVersion: 2,
    336     savedEditVersion: 2,
    337     form: { title: 'clock reentrant latest' },
    338     draft: { revision: 1, form: { title: 'clock reentrant latest' } }
    339   });
    340   expect(result.rows).toEqual({ ok: true, value: [result.snapshot?.draft] });
    341 });