Header Annuler/Retablir on every tab (aria-disabled, commit on pointerdown, refused blur commit skips the undo). Save line: unsaved count selector (savedDistance), saveLineState forms, server save time via readSaveTime (lastSave in the store, never the browser clock). Discard relabelled and names the stored copy. Tool column pair removed, glyphs in EditorGlyph. Rewritten or removed assertions (R-24): - editor-route.test: Revision 3 / unsaved text / Annuler les modifications -> save-line testid, Abandonner label, copy sentence in the dialog - editor-route-conflict, editor-route-recovery: Revision n and copy_cap/ copy_quota text queries -> save-line testid - editor-no-loss: discard button label - editor-annotations-tab: tool column undo/redo test -> no pair left (behaviour moved to editor-history-buttons.test) - e2e journey/annotations/recovery/structures/support saveDraft/lan: undo/redo and revision/unsaved text -> historyButton, saveLine helpers; structures toHaveCount(0) on old text -> exact Revision n line - editor-shell clickability: header Annuler/Retablir added
368 lines
12 KiB
TypeScript
368 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 {
|
|
VERSION,
|
|
commitMove,
|
|
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 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/,
|
|
)
|
|
})
|
|
})
|