Files
faunosteo/apps/app/tests/unit/editor-store.test.ts
T

388 lines
17 KiB
TypeScript

/** 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<typeof import('@faunosteo/supabase')>()),
getSheetVersion: vi.fn(),
downloadSheetDrawing: vi.fn(),
saveSheetDraft: vi.fn(),
getOfficialSheetAdmin: vi.fn(),
submitSheetReview: vi.fn(),
}))
afterEach(resetStore)
function deferred<T>() {
let resolve!: (value: T) => void
let reject!: (error: unknown) => void
const promise = new Promise<T>((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('<svg/>'))
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<unknown>()
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<unknown>()
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<unknown>()
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<unknown>()
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<unknown>().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<string, unknown>) => ({
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<unknown>().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<unknown>()
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()
})
})