Files
faunosteo/apps/app/tests/unit/editor-history-guards.test.tsx
T
bchanot e01d8519ea fix(editor): sign-out and shell links ask the drawing guard first
With a started move, sign-out and an in-app link now ask « Abandonner
le déplacement ? » (R-12) through the page's own question, registered by
the draft route in leaveGuardStore (`ask`; the shell imports no editor
module). The generic leave and sign-out dialogs cover only sheet-level
unsaved work; with both pending the drawing asks first, then the sheet
question, as useLeaveConfirm orders them. A move with nothing started
arms nothing (it ends); a started one still guards a reload.

Tests: sign-out and link with a started move (alone and with sheet
changes), the history jump with only a move and after dirty layers, a
section entry and « Tout afficher ».
2026-11-17 19:25:04 +01:00

479 lines
17 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/** R2F-1/2: guard stack, announcer queue, a Back over the finding layers. */
import { afterEach, describe, expect, it, vi } from 'vitest'
import {
act,
cleanup,
fireEvent,
render,
renderHook,
screen,
waitFor,
within,
} from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import type { ElementKey } from '@faunosteo/core-wasm/types'
import {
MemoryRouter,
useLocation,
useNavigate,
type Location,
type NavigateFunction,
} from 'react-router-dom'
import { flushAfterModals } from '@/components/ui/afterModalsClosed'
import { useBeforeUnload } from '@/app/useLeaveGuard'
import EditorTabs from '@/components/editor/EditorTabs'
import { ENTRY_KEY, type HistoryEntry } from '@/editor/history/entry'
import useEditorHistory from '@/editor/history/useEditorHistory'
import { defaultView, targetOfKey } from '@/editor/navigation'
import { useEditorNavigation } from '@/editor/useEditorNavigation'
import { useLocaleStore } from '@/state/localeStore'
import DrawingGuardDialog from '@/components/editor/annotations/DrawingGuardDialog'
import {
resetWork,
setModePreview,
startMove,
useAnnotationWork,
} from '@/editor/annotations/workStore'
afterEach(cleanup)
const owner = { sheetId: 'S', tag: 'T' }
const finding: ElementKey = {
kind: 'finding',
zone_id: 'zone',
path: ['family', 'node'],
}
const other: ElementKey = {
kind: 'finding',
zone_id: 'zone',
path: ['family', 'other'],
}
let navigate: NavigateFunction
let location: Location
const entry = () => (location.state as Record<string, HistoryEntry>)[ENTRY_KEY]
function Page({ guard }: { guard?: () => { allowed: boolean } }) {
const nav = useEditorNavigation('general')
navigate = useNavigate()
location = useLocation()
useEditorHistory(nav, owner, defaultView('general'))
return (
<>
<EditorTabs active={nav.state.tab} tier="wide" onSelect={nav.selectTab} />
<button onClick={() => nav.openFinding(finding)}>open</button>
<button onClick={() => nav.openCitations(finding)}>cite</button>
<button onClick={() => nav.closeCitations()}>uncite</button>
<button onClick={() => nav.closeFinding()}>close</button>
<button onClick={() => nav.showAllReferences(finding)}>show all</button>
<button onClick={() => nav.navigate(targetOfKey(other))}>go to</button>
<button onClick={() => nav.openSection('views')}>section</button>
<button onClick={() => nav.guards.register('finding', guard ?? null)}>
guard
</button>
<p data-testid="layer">{JSON.stringify(nav.state.finding)}</p>
<button onClick={() => nav.announce('one')}>say one</button>
<button onClick={() => nav.announce('two')}>say two</button>
<p data-testid="live">{nav.live}</p>
<DrawingGuardDialog />
</>
)
}
const mount = (
guard?: () => { allowed: boolean },
entries: string[] = ['/x'],
) =>
render(
<MemoryRouter initialEntries={entries} initialIndex={entries.length - 1}>
<Page guard={guard} />
</MemoryRouter>,
)
describe('a Back over the finding layers', () => {
async function openSheet(guard?: () => { allowed: boolean }) {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount(guard)
if (guard) await user.click(screen.getByRole('button', { name: 'guard' }))
await user.click(screen.getByRole('tab', { name: 'Constats' }))
await user.click(screen.getByRole('button', { name: 'open' }))
await user.click(screen.getByRole('button', { name: 'cite' }))
return user
}
const layer = () => JSON.parse(screen.getByTestId('layer').textContent!)
it('closes the sheet first, then the dialog, one layer per entry', async () => {
await openSheet()
expect(layer()).toMatchObject({ citations: true })
expect(entry().below?.finding).toMatchObject({ citations: false })
act(() => navigate(-1))
expect(layer()).toMatchObject({ citations: false })
act(() => navigate(-1))
expect(layer()).toBeNull()
expect(screen.getByRole('tab', { selected: true })).toHaveTextContent(
'Constats',
)
})
it('a dirty layer keeps the page where it is: asked, the view pushed again', async () => {
const guard = vi.fn(() => ({ allowed: false }))
await openSheet(guard)
// The sheet is no form: the Back that closes it alone asks nothing (rev 4, item 1).
act(() => navigate(-1))
expect(guard).not.toHaveBeenCalled()
expect(layer()).toMatchObject({ citations: false })
const before = entry().id
act(() => navigate(-1))
expect(guard).toHaveBeenCalledWith(false)
expect(layer()).toMatchObject({ citations: false })
expect(entry().id).not.toBe(before)
expect(entry().view.finding).toMatchObject({ citations: false })
expect(entry().below?.finding).toBeNull()
})
it('a jump that removes a dirty dialog under the sheet closes the sheet, then asks', async () => {
const guard = vi.fn(() => ({ allowed: false }))
await openSheet(guard)
act(() => navigate(-2))
expect(guard).toHaveBeenCalledWith(false)
expect(layer()).toMatchObject({ citations: false })
expect(entry().view.finding).toMatchObject({ citations: false })
})
it('a modal that is no layer refuses the Back too', async () => {
await openSheet()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
act(() => navigate(-1))
expect(layer()).toMatchObject({ citations: true })
dialog.remove()
})
it('a layer dialog open does not refuse it', async () => {
await openSheet()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
dialog.setAttribute('data-layer', '')
document.body.append(dialog)
act(() => navigate(-1))
expect(layer()).toMatchObject({ citations: false })
dialog.remove()
})
})
describe('the guard stack', () => {
it('asks each layer on its own, and all of them top down', () => {
const { result } = renderHook(() => useEditorNavigation('general'))
const { guards } = result.current
const order: string[] = []
guards.register('reference', () => {
order.push('reference')
return { allowed: true, note: 'a' }
})
guards.register('finding', () => {
order.push('finding')
return { allowed: false, note: 'b' }
})
expect(guards.ask('reference', false)).toEqual({
allowed: true,
note: 'a',
})
expect(guards.ask('finding', true).allowed).toBe(false)
order.length = 0
// The reference dialog is the top layer: it is asked first.
expect(guards.askAll(false)).toEqual({ allowed: false, note: 'a. b' })
expect(order).toEqual(['reference', 'finding'])
guards.register('finding', null)
expect(guards.askAll(false).allowed).toBe(true)
})
})
describe('the announcer', () => {
it('says what is announced at once while no dialog is open', async () => {
mount()
await userEvent.click(screen.getByRole('button', { name: 'say one' }))
expect(screen.getByTestId('live')).toHaveTextContent('one')
})
it('joins what is announced under an open dialog into one announcement', async () => {
const user = userEvent.setup()
mount()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
await user.click(screen.getByRole('button', { name: 'say one' }))
await user.click(screen.getByRole('button', { name: 'say two' }))
expect(screen.getByTestId('live')).toHaveTextContent('')
dialog.remove()
act(() => flushAfterModals())
expect(screen.getByTestId('live')).toHaveTextContent('one. two')
})
})
describe('the announcer, a wait that never fires', () => {
it('does not hold later messages back', async () => {
const user = userEvent.setup()
mount()
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
document.body.append(dialog)
await user.click(screen.getByRole('button', { name: 'say one' }))
// the dialog goes without ModalDialog's cleanup: nothing flushes the queue
dialog.remove()
await user.click(screen.getByRole('button', { name: 'say two' }))
expect(screen.getByTestId('live')).toHaveTextContent('one. two')
})
})
describe('useBeforeUnload', () => {
it('asks while dirty and stops when clean', () => {
const { rerender } = renderHook(({ dirty }) => useBeforeUnload(dirty), {
initialProps: { dirty: true },
})
const first = new Event('beforeunload', { cancelable: true })
window.dispatchEvent(first)
expect(first.defaultPrevented).toBe(true)
rerender({ dirty: false })
const second = new Event('beforeunload', { cancelable: true })
window.dispatchEvent(second)
expect(second.defaultPrevented).toBe(false)
})
})
const click = (name: string) =>
userEvent.click(screen.getByRole('button', { name }))
const findingLayer = () => JSON.parse(screen.getByTestId('layer').textContent!)
/** A layer dialog on screen: what a Back that reopens the layers shows. */
function openLayerDialog() {
const dialog = document.createElement('dialog')
dialog.setAttribute('open', '')
dialog.setAttribute('data-layer', '')
document.body.append(dialog)
return dialog
}
async function settleDialogs(dialog: HTMLElement) {
dialog.remove()
await act(async () => {
flushAfterModals()
await Promise.resolve()
await Promise.resolve()
})
}
const setScrollY = (y: number) =>
Object.defineProperty(window, 'scrollY', {
configurable: true,
writable: true,
value: y,
})
describe('final review: a Back into the layers (I-1)', () => {
afterEach(() => {
setScrollY(0)
vi.restoreAllMocks()
})
it('restores the page scroll, however the dialogs are closed afterwards', async () => {
useLocaleStore.setState({ locale: 'fr' })
const scrollTo = vi.spyOn(window, 'scrollTo').mockImplementation(() => {})
mount()
await userEvent.click(screen.getByRole('tab', { name: 'Constats' }))
setScrollY(500)
await click('open')
await click('cite')
await click('show all')
setScrollY(0)
scrollTo.mockClear()
const dialog = openLayerDialog()
act(() => navigate(-1))
expect(findingLayer()).toMatchObject({ citations: true })
// Closed by ✕ / Escape: each close dispatches and renders again.
await click('uncite')
await click('close')
await settleDialogs(dialog)
expect(scrollTo).toHaveBeenCalledWith(0, 500)
})
})
describe('final review: « Aller à » from the sheet (I-2)', () => {
it('keeps the entry of the finding with its sheet: Back from the target returns to it', async () => {
useLocaleStore.setState({ locale: 'fr' })
mount()
await userEvent.click(screen.getByRole('tab', { name: 'Constats' }))
await click('open')
await click('cite')
await click('go to')
expect(findingLayer()).toEqual({ key: other, citations: false })
expect(entry().below?.finding).toEqual({ key: finding, citations: true })
act(() => navigate(-1))
expect(findingLayer()).toEqual({ key: finding, citations: true })
})
})
describe('final review: a location that is not the editor’s (M-3)', () => {
it('writes nothing and asks no layer on a Back to another page', async () => {
useLocaleStore.setState({ locale: 'fr' })
const guard = vi.fn(() => ({ allowed: false }))
mount(guard, ['/y', '/x'])
await click('guard')
await userEvent.click(screen.getByRole('tab', { name: 'Constats' }))
await click('open')
act(() => navigate(-3))
expect(location.pathname).toBe('/y')
expect(location.state).toBeNull()
expect(guard).not.toHaveBeenCalled()
})
})
describe('final review: entry ids (M-4)', () => {
it('two mounts never share an entry id', async () => {
mount()
await waitFor(() => expect(entry()).toBeTruthy())
const first = entry().id
cleanup()
mount()
await waitFor(() => expect(entry()).toBeTruthy())
expect(entry().id).not.toBe(first)
})
})
describe('final review: past the write budget (M-5)', () => {
it('a close over a push kept in memory never goes back a real entry', async () => {
useLocaleStore.setState({ locale: 'fr' })
mount()
const tabOf = (name: string) => screen.getByRole('tab', { name })
fireEvent.click(tabOf('Constats'))
for (let i = 0; i < 19; i += 1) {
fireEvent.click(tabOf('Général'))
fireEvent.click(tabOf('Constats'))
}
// The 40th write of the window: sent. The 41st (the sheet) stays in memory.
fireEvent.click(screen.getByRole('button', { name: 'open' }))
fireEvent.click(screen.getByRole('button', { name: 'cite' }))
const top = location.key
fireEvent.click(screen.getByRole('button', { name: 'uncite' }))
expect(findingLayer()).toEqual({ key: finding, citations: false })
expect(screen.getByRole('tab', { selected: true })).toHaveTextContent(
'Constats',
)
expect(location.key).toBe(top)
expect(entry().view.finding).toEqual({ key: finding, citations: false })
})
})
describe('final review: queued landings (M-6)', () => {
it('a Back during the exit cancels the stale « Tout afficher » landing', async () => {
useLocaleStore.setState({ locale: 'fr' })
mount()
await userEvent.click(screen.getByRole('tab', { name: 'Constats' }))
await click('open')
await click('cite')
const exiting = openLayerDialog()
await click('show all')
act(() => navigate(-1))
expect(findingLayer()).toMatchObject({ citations: true })
const focused: Element[] = []
const record = (event: FocusEvent) => focused.push(event.target as Element)
document.addEventListener('focusin', record)
await settleDialogs(exiting)
document.removeEventListener('focusin', record)
const references = screen.getByRole('tab', { name: 'Références' })
expect(focused).not.toContain(references)
})
})
describe('the drawing guard (R-12): a move mode and the navigations', () => {
const STORED = { type: 'circle' as const, cx: 1, cy: 2, r: 3 }
afterEach(resetWork)
const tabShown = () => screen.getByRole('tab', { selected: true })
const started = () => {
startMove('a', 'doc')
setModePreview({ ...STORED, cx: 9 }, STORED)
}
it('with no step taken, a tab ends the mode at once, without a question', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
startMove('a', 'doc')
await user.click(screen.getByRole('tab', { name: 'Constats' }))
expect(tabShown()).toHaveTextContent('Constats')
expect(useAnnotationWork.getState().mode).toBeNull()
expect(screen.queryByRole('dialog')).toBeNull()
})
it('after one step a tab asks; « Continuer » keeps the mode and its position', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
started()
await user.click(screen.getByRole('tab', { name: 'Constats' }))
const dialog = screen.getByRole('dialog', {
name: 'Abandonner le déplacement ?',
})
expect(tabShown()).toHaveTextContent('Général')
await user.click(within(dialog).getByRole('button', { name: 'Continuer' }))
expect(tabShown()).toHaveTextContent('Général')
expect(useAnnotationWork.getState().preview?.geometry).toMatchObject({
cx: 9,
})
await user.click(screen.getByRole('tab', { name: 'Constats' }))
await user.click(screen.getByRole('button', { name: 'Abandonner' }))
expect(tabShown()).toHaveTextContent('Constats')
expect(useAnnotationWork.getState().mode).toBeNull()
})
it('a section entry and « Tout afficher » ask the same way', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
started()
await user.click(screen.getByRole('button', { name: 'section' }))
expect(useAnnotationWork.getState().question?.work).toBe('move')
expect(tabShown()).toHaveTextContent('Général')
await user.click(screen.getByRole('button', { name: 'Continuer' }))
await user.click(screen.getByRole('button', { name: 'show all' }))
expect(useAnnotationWork.getState().question?.work).toBe('move')
expect(tabShown()).toHaveTextContent('Général')
await user.click(screen.getByRole('button', { name: 'Abandonner' }))
expect(tabShown()).toHaveTextContent('Références')
})
it('« Aller à » asks the same way', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
started()
await user.click(screen.getByRole('button', { name: 'go to' }))
expect(
screen.getByRole('dialog', { name: 'Abandonner le déplacement ?' }),
).toBeInTheDocument()
expect(tabShown()).toHaveTextContent('Général')
})
it('a Back asks and keeps the view; an unstarted mode lets it go and ends', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
await user.click(screen.getByRole('tab', { name: 'Constats' }))
started()
act(() => navigate(-1))
expect(tabShown()).toHaveTextContent('Constats')
expect(
screen.getByRole('dialog', { name: 'Abandonner le déplacement ?' }),
).toBeInTheDocument()
await user.click(screen.getByRole('button', { name: 'Abandonner' }))
expect(useAnnotationWork.getState().mode).toBeNull()
// As after a layer's question, the Back is not replayed: the user goes Back again.
expect(tabShown()).toHaveTextContent('Constats')
await waitFor(() =>
expect(document.querySelector('dialog[open]')).toBeNull(),
)
startMove('a', 'doc')
act(() => navigate(-1))
expect(tabShown()).toHaveTextContent('Général')
expect(useAnnotationWork.getState().mode).toBeNull()
})
})