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