/** Lot D: the editor store on the Node core, Supabase accessors mocked at the module boundary. */ import { afterEach, describe, expect, it, vi } from 'vitest' import { SheetFailure } from '@faunosteo/supabase' import { leaveGuardArmed, canRedo, canUndo } from '@/editor/state/editorStore' import { USER, VERSION, baseText, commitMove, moveCommand, openReady, resetStore, sb, serverHas, storedCopy, store, } from '../helpers/editorHarness' import { ASSET } from '../helpers/editorFixtures' vi.mock('@/lib/supabase', () => ({ getSupabaseClient: () => ({}) })) vi.mock('@faunosteo/supabase', async (orig) => ({ ...(await orig()), getSheetVersion: vi.fn(), downloadSheetDrawing: vi.fn(), saveSheetDraft: vi.fn(), getOfficialSheetAdmin: vi.fn(), submitSheetReview: vi.fn(), })) afterEach(resetStore) function deferred() { let resolve!: (value: T) => void let reject!: (error: unknown) => void const promise = new Promise((res, rej) => { resolve = res reject = rej }) return { promise, resolve, reject } } describe('open and sessions', () => { it('loads the draft with its revision and drawings from one read', async () => { await openReady({ revision: 3 }) const state = store.getState() expect(state).toMatchObject({ status: 'ready', savedRevision: 3, unsaved: false, recovery: 'none' }) expect(state.documentText).toBe(state.savedText) expect(state.drawings).toEqual([expect.objectContaining({ asset_id: ASSET })]) expect(state.previewState?.drawings[0]).toMatchObject({ state: 'ok' }) expect(state.handleVersion).toBe(1) }) it('does not fail the load on a drawing that cannot be downloaded', async () => { sb.downloadSheetDrawing.mockRejectedValue(new SheetFailure('not_found')) serverHas(baseText(), 3) sb.downloadSheetDrawing.mockRejectedValue(new SheetFailure('not_found')) store.getState().open(VERSION, USER) await vi.waitFor(() => expect(store.getState().status).toBe('ready')) expect(store.getState().drawingFailures[ASSET]).toBe('drawing_missing') expect(store.getState().previewState?.drawings[0]).toMatchObject({ state: 'missing' }) }) it('records a drawing whose bytes fail the hash check at load', async () => { serverHas(baseText(), 3) sb.downloadSheetDrawing.mockResolvedValue(new TextEncoder().encode('')) store.getState().open(VERSION, USER) await vi.waitFor(() => expect(store.getState().status).toBe('ready')) expect(store.getState().drawingFailures[ASSET]).toBe('drawing_hash_mismatch') expect(store.getState().drawings).toEqual([]) }) it('drops a late load after close and frees the preview it built', async () => { const late = deferred() sb.getSheetVersion.mockReturnValue(late.promise as never) store.getState().open(VERSION, USER) store.getState().close() late.resolve({}) await Promise.resolve() expect(store.getState()).toMatchObject({ status: 'idle', preview: null }) }) it('lets the second open of a StrictMode double mount win over the first', async () => { const first = deferred() sb.getSheetVersion.mockReturnValueOnce(first.promise as never) const one = store.getState().open(VERSION, USER) store.getState().close() serverHas(baseText(), 7) const two = store.getState().open(VERSION, USER) expect(two).toBeGreaterThan(one) await vi.waitFor(() => expect(store.getState().status).toBe('ready')) first.resolve({ sheet_id: 'x' }) await Promise.resolve() expect(store.getState().savedRevision).toBe(7) }) it('drops a save answer that lands after close', async () => { await openReady() commitMove(40) const answer = deferred() sb.saveSheetDraft.mockReturnValue(answer.promise as never) const saving = store.getState().save() store.getState().close() answer.resolve({ revision: 4 }) expect(await saving).toMatchObject({ ok: false, reason: 'blocked', kind: 'session_changed' }) expect(store.getState()).toMatchObject({ status: 'idle', savedRevision: 0 }) }) }) describe('commit, undo, redo', () => { it('commits in one store update', async () => { await openReady() const before = store.getState() expect(commitMove(40)).toEqual({ ok: true }) const after = store.getState() expect(after.documentText).not.toBe(before.documentText) expect(after).toMatchObject({ unsaved: true, handleVersion: before.handleVersion + 1 }) expect(after.undo).toHaveLength(1) expect(after.previewState).not.toBe(before.previewState) }) it('keeps nothing on a core refusal or an accept refusal', async () => { await openReady() const before = store.getState() const missing = store.getState().commit({ op: 'remove', key: { kind: 'annotation', id: 'nope' } }) expect(missing).toMatchObject({ ok: false, reason: 'core' }) const refused = store.getState().commit(moveCommand(40), { accept: () => ({ accepted: false, refusal: 'no' as const }), }) expect(refused).toEqual({ ok: false, reason: 'refused', refusal: 'no' }) const after = store.getState() expect(after.documentText).toBe(before.documentText) expect(after.handleVersion).toBe(before.handleVersion) expect(after.undo).toHaveLength(0) expect(storedCopy()).toBeNull() expect(after.preview?.document).toBe(before.documentText) }) it('undoes, redoes, and clears redo on a new commit', async () => { await openReady() const saved = store.getState().documentText commitMove(40) commitMove(30) expect(store.getState().undoStep()).toEqual({ ok: true }) expect(canRedo(store.getState())).toBe(true) expect(store.getState().redoStep()).toEqual({ ok: true }) store.getState().undoStep() commitMove(20) expect(canRedo(store.getState())).toBe(false) expect(store.getState().undo).toHaveLength(2) store.getState().undoStep() store.getState().undoStep() expect(store.getState().documentText).toBe(saved) expect(store.getState().unsaved).toBe(false) expect(canUndo(store.getState())).toBe(false) expect(store.getState().undoStep()).toMatchObject({ ok: false, kind: 'empty' }) }) it('keeps the copy when undo returns to the saved content', async () => { await openReady() commitMove(40) const written = storedCopy() store.getState().undoStep() expect(store.getState().unsaved).toBe(false) expect(storedCopy()).toEqual(written) }) it('refuses every change in a read-only mode', async () => { await openReady({ canEdit: false }) expect(commitMove(40)).toMatchObject({ ok: false, kind: 'read_only' }) }) }) describe('save', () => { it('saves against the saved revision and removes the copy', async () => { await openReady({ revision: 3 }) commitMove(40) expect(storedCopy()).not.toBeNull() sb.saveSheetDraft.mockResolvedValue({ revision: 4 } as never) const sent = store.getState().documentText expect(await store.getState().save()).toEqual({ ok: true, revision: 4 }) expect(sb.saveSheetDraft).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ version_id: VERSION, expected_revision: 3 }), ) expect(store.getState()).toMatchObject({ savedRevision: 4, savedText: sent, unsaved: false }) expect(storedCopy()).toBeNull() expect(leaveGuardArmed(store.getState())).toBe(false) }) it('keeps the sent text and rewrites the copy on the new revision for commits in flight', async () => { await openReady({ revision: 3 }) commitMove(40) const sent = store.getState().documentText const answer = deferred() sb.saveSheetDraft.mockReturnValue(answer.promise as never) const saving = store.getState().save() commitMove(30) const latest = store.getState().documentText answer.resolve({ revision: 4 }) await saving expect(store.getState()).toMatchObject({ savedText: sent, savedRevision: 4, unsaved: true }) expect(storedCopy()).toMatchObject({ revision: 4, document: JSON.parse(latest) }) }) it('treats draft.unchanged as saved at the revision sent', async () => { await openReady({ revision: 3 }) commitMove(40) sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft.unchanged')) const sent = store.getState().documentText expect(await store.getState().save()).toEqual({ ok: true, revision: 3 }) expect(store.getState()).toMatchObject({ savedText: sent, savedRevision: 3, unsaved: false }) expect(storedCopy()).toBeNull() }) it('keeps the document and the copy on any other server kind', async () => { await openReady() commitMove(40) sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft.frozen')) expect(await store.getState().save()).toEqual({ ok: false, reason: 'server', kind: 'draft.frozen' }) expect(store.getState()).toMatchObject({ unsaved: true, saveFailure: 'draft.frozen', saving: false }) expect(storedCopy()).not.toBeNull() }) it('refuses a second save while one is in flight', async () => { await openReady() commitMove(40) sb.saveSheetDraft.mockReturnValue(deferred().promise as never) void store.getState().save() expect(await store.getState().save()).toMatchObject({ ok: false, kind: 'busy' }) }) }) describe('conflict', () => { async function conflicted(admin: unknown | 'fail', revision = 5) { await openReady({ revision: 3 }) commitMove(40) sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft_conflict')) if (admin === 'fail') sb.getOfficialSheetAdmin.mockRejectedValue(new SheetFailure('network')) else sb.getOfficialSheetAdmin.mockResolvedValue(admin as never) const outcome = await store.getState().save() expect(outcome).toMatchObject({ ok: false, kind: 'draft_conflict' }) return revision } const adminWith = (over: Record) => ({ draft_version: { version_id: VERSION, version_number: 1, revision: 5 }, draft_last_save: null, ...over, }) it('takes N from draft_version and the author only when draft_last_save matches N', async () => { const person = { user_id: 'other', display_name: 'Marie' } await conflicted(adminWith({ draft_last_save: { revision: 5, saved_at: 'T', saved_by: person } })) expect(store.getState().conflict).toEqual({ status: 'known', revision: 5, lastSave: { savedAt: 'T', savedBy: person, byCaller: false }, }) }) it('omits the author when draft_last_save is for another revision, flags the caller', async () => { await conflicted(adminWith({ draft_last_save: { revision: 4, saved_at: 'T', saved_by: null } })) expect(store.getState().conflict).toEqual({ status: 'known', revision: 5, lastSave: null }) const me = { user_id: USER, display_name: 'Moi' } sb.getOfficialSheetAdmin.mockResolvedValue( adminWith({ draft_last_save: { revision: 5, saved_at: 'T', saved_by: me } }) as never, ) await store.getState().retryConflictRead() expect(store.getState().conflict).toMatchObject({ lastSave: { byCaller: true } }) }) it('is unknown on a failed read, another version or no draft_version, and refuses keepMine', async () => { await conflicted('fail') expect(store.getState().conflict).toEqual({ status: 'unknown' }) expect(await store.getState().keepMine({ confirmed: true })).toMatchObject({ kind: 'revision_unknown' }) sb.getOfficialSheetAdmin.mockResolvedValue( adminWith({ draft_version: { version_id: 'other', version_number: 1, revision: 9 } }) as never, ) await store.getState().retryConflictRead() expect(store.getState().conflict).toEqual({ status: 'unknown' }) sb.getOfficialSheetAdmin.mockResolvedValue(adminWith({ draft_version: null }) as never) await store.getState().retryConflictRead() expect(store.getState().conflict).toEqual({ status: 'unknown' }) }) it('keeps my version only after confirmation, against N', async () => { await conflicted(adminWith({})) sb.saveSheetDraft.mockClear() expect(await store.getState().keepMine({ confirmed: false })).toMatchObject({ kind: 'confirmation_required' }) expect(sb.saveSheetDraft).not.toHaveBeenCalled() sb.saveSheetDraft.mockResolvedValue({ revision: 6 } as never) expect(await store.getState().keepMine({ confirmed: true })).toEqual({ ok: true, revision: 6 }) expect(sb.saveSheetDraft).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ expected_revision: 5 }), ) expect(store.getState()).toMatchObject({ savedRevision: 6, unsaved: false, conflict: null }) }) it('re-reads on a new conflict and never writes by itself', async () => { await conflicted(adminWith({})) sb.saveSheetDraft.mockClear() sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft_conflict')) sb.getOfficialSheetAdmin.mockResolvedValue( adminWith({ draft_version: { version_id: VERSION, version_number: 1, revision: 8 } }) as never, ) await store.getState().keepMine({ confirmed: true }) expect(sb.saveSheetDraft).toHaveBeenCalledTimes(1) expect(store.getState().conflict).toMatchObject({ status: 'known', revision: 8 }) store.getState().dismissConflict() expect(store.getState()).toMatchObject({ conflict: null, unsaved: true, savedRevision: 3 }) }) it('reloads the server draft after confirmation: stacks cleared, copy removed', async () => { await conflicted(adminWith({})) const server = baseText().replace('"Fiche"', '"Serveur"') serverHas(server, 5) expect(await store.getState().reloadServerDraft({ confirmed: false })).toMatchObject({ kind: 'confirmation_required' }) expect(storedCopy()).not.toBeNull() expect(await store.getState().reloadServerDraft({ confirmed: true })).toEqual({ ok: true }) expect(store.getState()).toMatchObject({ savedRevision: 5, unsaved: false, conflict: null, undo: [], redo: [], staleBase: false, }) expect(store.getState().documentText).toBe(JSON.stringify(JSON.parse(server))) expect(storedCopy()).toBeNull() expect(sb.downloadSheetDrawing).toHaveBeenCalledTimes(1) }) }) describe('discard and submit', () => { it('discards back to the saved text after confirmation, clears stacks, removes the copy', async () => { await openReady() const saved = store.getState().savedText commitMove(40) expect(await store.getState().discardChanges({ confirmed: false })).toMatchObject({ kind: 'confirmation_required' }) expect(await store.getState().discardChanges({ confirmed: true })).toEqual({ ok: true }) expect(store.getState()).toMatchObject({ documentText: saved, unsaved: false, undo: [], redo: [] }) expect(storedCopy()).toBeNull() }) it('submits the saved revision and never re-submits on a conflict', async () => { await openReady({ revision: 3 }) sb.submitSheetReview.mockResolvedValue('review-1' as never) expect(await store.getState().submit()).toEqual({ ok: true, reviewId: 'review-1' }) expect(sb.submitSheetReview).toHaveBeenCalledWith(expect.anything(), { version_id: VERSION, expected_revision: 3 }) // The accepted submission froze the store; a fresh session meets the conflict. await openReady({ revision: 3 }) sb.submitSheetReview.mockRejectedValue(new SheetFailure('draft_conflict')) sb.getOfficialSheetAdmin.mockRejectedValue(new SheetFailure('network')) expect(await store.getState().submit()).toMatchObject({ kind: 'draft_conflict' }) expect(sb.submitSheetReview).toHaveBeenCalledTimes(2) expect(store.getState().conflict).toEqual({ status: 'unknown' }) }) }) describe('after the server accepted the submission', () => { it('takes no further change before the sheet reload turns the draft frozen', async () => { await openReady({ revision: 3 }) sb.submitSheetReview.mockResolvedValue('review-1' as never) expect(await store.getState().submit()).toMatchObject({ ok: true }) expect(commitMove(40)).toMatchObject({ ok: false, reason: 'blocked', kind: 'read_only' }) expect(store.getState().unsaved).toBe(false) }) }) describe('guards', () => { it('refuses a submit while the document differs from the saved text', async () => { await openReady() commitMove(40) expect(await store.getState().submit()).toMatchObject({ ok: false, kind: 'unsaved' }) expect(sb.submitSheetReview).not.toHaveBeenCalled() }) it('refuses a discard while a save is in flight', async () => { await openReady() commitMove(40) sb.saveSheetDraft.mockReturnValue(deferred().promise as never) void store.getState().save() expect(await store.getState().discardChanges({ confirmed: true })).toMatchObject({ kind: 'busy' }) expect(store.getState().unsaved).toBe(true) }) it('drops a conflict read that lands after dismissal', async () => { await openReady() commitMove(40) const late = deferred() sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft_conflict')) sb.getOfficialSheetAdmin.mockReturnValue(late.promise as never) const saving = store.getState().save() await vi.waitFor(() => expect(store.getState().conflict).toEqual({ status: 'reading' })) store.getState().dismissConflict() late.resolve({ draft_version: { version_id: VERSION, version_number: 1, revision: 5 }, draft_last_save: null }) await saving expect(store.getState().conflict).toBeNull() }) })