388 lines
17 KiB
TypeScript
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()
|
|
})
|
|
})
|