Files
faunosteo/apps/app/tests/unit/editor-save-line.test.ts
T
bchanot 89da8d3f55 fix(editor): keyboard refused-commit rule, missing history tests
Keyboard activation after a refused blur commit skips the undo and refocuses the field. Adds restore, Général-from-Annotations and DeleteDialog tests; SaveLine helpers.
2026-11-08 18:09:10 +01:00

387 lines
12 KiB
TypeScript

/** Lot E: the unsaved-count selector, the save line's forms and the server save time. */
import { afterEach, describe, expect, it, vi } from 'vitest'
import { SheetFailure } from '@faunosteo/supabase'
import { saveLineState, savedDistance } from '@/editor/saveLine'
import {
HISTORY_LIMIT_BYTES,
emptyHistory,
recordCommit,
stepBack,
stepForward,
entryOf,
} from '@/editor/state/undo'
import saveLineSource from '@/editor/saveLine.ts?raw'
import saveSource from '@/editor/state/editorSave.ts?raw'
import {
SHEET,
USER,
VERSION,
baseText,
commitMove,
copyKeyOf,
openReady,
resetStore,
sb,
store,
} from '../helpers/editorHarness'
import { adminAnswer } from '../helpers/editorRoute'
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)
const distance = () => savedDistance(store.getState())
const SAVED_AT = '2026-11-04T13:32:00Z'
function deferred<T>() {
let resolve!: (value: T) => void
const promise = new Promise<T>((res) => {
resolve = res
})
return { promise, resolve }
}
function adminAt(revision: number, version = VERSION) {
return adminAnswer({
draft_version: { version_id: version, version_number: 4, revision },
draft_last_save: { revision, saved_at: SAVED_AT, saved_by: null },
}) as never
}
describe('savedDistance', () => {
it('is 0 at load and counts commits', async () => {
await openReady({ revision: 3 })
expect(distance()).toBe(0)
commitMove(40)
expect(distance()).toBe(1)
commitMove(41)
expect(distance()).toBe(2)
})
it('follows undo and redo around the save point', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
store.getState().undoStep()
expect(distance()).toBe(1)
store.getState().undoStep()
expect(distance()).toBe(0)
store.getState().redoStep()
expect(distance()).toBe(1)
})
it('counts the redo side when the save point lies ahead', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
sb.saveSheetDraft.mockResolvedValue({ revision: 4 } as never)
await store.getState().save()
store.getState().undoStep()
store.getState().undoStep()
expect(distance()).toBe(2)
})
it('is null once a commit follows an undo past the save point', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
sb.saveSheetDraft.mockResolvedValue({ revision: 4 } as never)
await store.getState().save()
store.getState().undoStep()
store.getState().undoStep()
commitMove(50)
expect(distance()).toBeNull()
})
it('is null after a restored recovery copy', async () => {
const copy = JSON.parse(baseText(), (key, value) => (key === 'cx' ? 10 : value))
sessionStorage.setItem(
copyKeyOf(),
JSON.stringify({
v: 1, user_id: USER, version_id: VERSION, sheet_id: SHEET, sheet_name: 'Fiche',
revision: 3, written_at: '2026-11-03T10:00:00Z', document: copy, drawings: [],
}),
)
await openReady({ revision: 3 })
expect(await store.getState().restoreCopy()).toEqual({ ok: true })
expect(store.getState().unsaved).toBe(true)
expect(distance()).toBeNull()
})
it('is null for a stale base', async () => {
await openReady({ revision: 3 })
commitMove(40)
store.setState({ staleBase: true })
expect(distance()).toBeNull()
})
it('is null once a trim dropped the saved text (commit, undo and redo)', () => {
const big = (mark: string) => mark.repeat(HISTORY_LIMIT_BYTES + 1)
const state = (history: ReturnType<typeof emptyHistory>, text: string) => ({
staleBase: false,
documentText: text,
savedText: 'saved',
...history,
})
const first = { undo: [entryOf('saved')], redo: [] }
expect(savedDistance(state(first, 'now'))).toBe(1)
const committed = recordCommit(first, big('a'))
expect(savedDistance(state(committed, 'now'))).toBeNull()
const undone = stepBack(
{ undo: [entryOf('saved'), entryOf('mid')], redo: [] },
big('b'),
)
expect(savedDistance(state(undone!.history, undone!.text))).toBeNull()
const ahead = { undo: [entryOf('saved')], redo: [entryOf('mid')] }
const redone = stepForward(ahead, big('d'))
expect(savedDistance(state(redone!.history, redone!.text))).toBeNull()
})
it('is null after changes made while a save was in flight moved off the save point', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
commitMove(42)
const answer = deferred<unknown>()
sb.saveSheetDraft.mockReturnValue(answer.promise as never)
const saving = store.getState().save()
store.getState().undoStep()
store.getState().undoStep()
commitMove(43)
commitMove(44)
commitMove(45)
answer.resolve({ revision: 4 })
await saving
expect(distance()).toBeNull()
})
it('is null for one undo and one commit in flight', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
const answer = deferred<unknown>()
sb.saveSheetDraft.mockReturnValue(answer.promise as never)
const saving = store.getState().save()
store.getState().undoStep()
commitMove(43)
answer.resolve({ revision: 4 })
await saving
expect(distance()).toBeNull()
})
it('the nearest duplicate of the saved text wins', async () => {
await openReady({ revision: 3 })
commitMove(40)
commitMove(41)
commitMove(40)
sb.saveSheetDraft.mockResolvedValue({ revision: 4 } as never)
await store.getState().save()
commitMove(42)
expect(distance()).toBe(1)
})
})
describe('saveLineState', () => {
const base = {
copyIssue: null,
saving: false,
unsaved: false,
distance: 0 as number | null,
lastSave: null,
savedRevision: 5,
}
it('gives the five forms, first match wins', () => {
const saved = { revision: 5, savedAt: SAVED_AT }
expect(
saveLineState({ ...base, copyIssue: 'cap', saving: true, unsaved: true }),
).toEqual({
kind: 'copy_issue',
issue: 'cap',
})
expect(saveLineState({ ...base, saving: true, unsaved: true })).toEqual({
kind: 'saving',
})
expect(
saveLineState({ ...base, unsaved: true, distance: 3, lastSave: saved }),
).toEqual({
kind: 'unsaved',
count: 3,
})
expect(saveLineState({ ...base, lastSave: saved })).toEqual({
kind: 'saved',
revision: 5,
savedAt: SAVED_AT,
})
expect(
saveLineState({ ...base, lastSave: { revision: 5, savedAt: null } }),
).toEqual({
kind: 'saved',
revision: 5,
savedAt: null,
})
expect(saveLineState(base)).toEqual({ kind: 'revision', revision: 5 })
})
it('has no count when the distance is unknown or zero', () => {
expect(saveLineState({ ...base, unsaved: true, distance: null })).toEqual({
kind: 'unsaved',
count: null,
})
expect(saveLineState({ ...base, unsaved: true, distance: 0 })).toEqual({
kind: 'unsaved',
count: null,
})
})
it('shows « Révision n » when the last save is of another revision', () => {
const old = { revision: 4, savedAt: SAVED_AT }
expect(saveLineState({ ...base, lastSave: old })).toEqual({
kind: 'revision',
revision: 5,
})
})
})
describe('readSaveTime', () => {
async function savedOnce() {
await openReady({ revision: 3 })
commitMove(40)
sb.saveSheetDraft.mockResolvedValue({ revision: 4 } as never)
}
it('writes the server time for this version and revision', async () => {
await savedOnce()
sb.getOfficialSheetAdmin.mockResolvedValue(adminAt(4))
expect(await store.getState().save()).toEqual({ ok: true, revision: 4 })
await vi.waitFor(() =>
expect(store.getState().lastSave).toEqual({
revision: 4,
savedAt: SAVED_AT,
}),
)
})
it('resolves the save before the read answers', async () => {
await savedOnce()
const read = deferred<never>()
sb.getOfficialSheetAdmin.mockReturnValue(read.promise)
expect(await store.getState().save()).toEqual({ ok: true, revision: 4 })
expect(store.getState().lastSave).toEqual({ revision: 4, savedAt: null })
read.resolve(adminAt(4))
await vi.waitFor(() =>
expect(store.getState().lastSave?.savedAt).toBe(SAVED_AT),
)
})
it('drops an answer for another version or another revision', async () => {
await savedOnce()
sb.getOfficialSheetAdmin.mockResolvedValue(adminAt(4, 'other'))
await store.getState().save()
await vi.waitFor(() =>
expect(sb.getOfficialSheetAdmin).toHaveBeenCalledTimes(1),
)
await Promise.resolve()
expect(store.getState().lastSave).toEqual({ revision: 4, savedAt: null })
commitMove(41)
sb.saveSheetDraft.mockResolvedValue({ revision: 5 } as never)
sb.getOfficialSheetAdmin.mockResolvedValue(adminAt(4))
await store.getState().save()
await vi.waitFor(() =>
expect(sb.getOfficialSheetAdmin).toHaveBeenCalledTimes(2),
)
await Promise.resolve()
expect(store.getState().lastSave).toEqual({ revision: 5, savedAt: null })
})
it('drops a late answer after another save', async () => {
await savedOnce()
const late = deferred<never>()
sb.getOfficialSheetAdmin.mockReturnValueOnce(late.promise)
await store.getState().save()
commitMove(41)
sb.saveSheetDraft.mockResolvedValue({ revision: 5 } as never)
sb.getOfficialSheetAdmin.mockResolvedValue(adminAt(5))
await store.getState().save()
await vi.waitFor(() =>
expect(store.getState().lastSave?.savedAt).toBe(SAVED_AT),
)
late.resolve(adminAt(4))
await Promise.resolve()
expect(store.getState().lastSave).toEqual({
revision: 5,
savedAt: SAVED_AT,
})
})
it('drops a late answer after a reload', async () => {
await savedOnce()
const late = deferred<never>()
sb.getOfficialSheetAdmin.mockReturnValue(late.promise)
await store.getState().save()
await store.getState().reloadServerDraft({ confirmed: true })
expect(store.getState().lastSave).toBeNull()
late.resolve(adminAt(4))
await Promise.resolve()
expect(store.getState().lastSave).toBeNull()
})
it('leaves the time unknown on a refusal, a failure or garbage', async () => {
await savedOnce()
sb.getOfficialSheetAdmin.mockRejectedValue(new SheetFailure('forbidden'))
await store.getState().save()
await vi.waitFor(() =>
expect(sb.getOfficialSheetAdmin).toHaveBeenCalledTimes(1),
)
expect(store.getState().lastSave).toEqual({ revision: 4, savedAt: null })
commitMove(41)
sb.saveSheetDraft.mockResolvedValue({ revision: 5 } as never)
sb.getOfficialSheetAdmin.mockResolvedValue(
adminAnswer({
draft_version: { version_id: VERSION, version_number: 4, revision: 5 },
draft_last_save: {
revision: 5,
saved_at: 'not a date',
saved_by: null,
},
}) as never,
)
await store.getState().save()
await vi.waitFor(() =>
expect(sb.getOfficialSheetAdmin).toHaveBeenCalledTimes(2),
)
await Promise.resolve()
expect(store.getState().lastSave).toEqual({ revision: 5, savedAt: null })
expect(store.getState().status).toBe('ready')
})
it('is not called on draft.unchanged nor on a failed save', async () => {
await openReady({ revision: 3 })
commitMove(40)
sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft.unchanged'))
await store.getState().save()
expect(store.getState().lastSave).toEqual({ revision: 3, savedAt: null })
sb.saveSheetDraft.mockRejectedValue(new SheetFailure('draft.frozen'))
commitMove(41)
await store.getState().save()
await Promise.resolve()
expect(sb.getOfficialSheetAdmin).not.toHaveBeenCalled()
})
it('never reads the browser clock', () => {
expect(saveLineSource).not.toMatch(/Date\.now|new Date/)
const read = saveSource.slice(saveSource.indexOf('function savedTimeOf'))
expect(read.slice(0, read.indexOf('interface Attempt'))).not.toMatch(
/Date\.now|new Date/,
)
})
})