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.
387 lines
12 KiB
TypeScript
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/,
|
|
)
|
|
})
|
|
})
|