Files
faunosteo/apps/app/tests/unit/editor-history-guards.test.tsx
T
bchanot ae80511964 fix(editor): redo and move-mode handle keys keep pending work
Final review I-1. Redo (Ctrl+Shift+Z and the header « Refaire ») is
inactive while a started move or redraw, a keyboard series or a size
change is pending (holdsRedo): the work stays, the user commits or
cancels it first. In a move mode, Insert and Delete on a vertex and
Enter or Space on « + » and « − » do nothing, as the press machine.

Tests: no assertion removed. The history-guards move-mode helper and
reset run in act, since « Refaire » now re-renders on a started mode.
2026-11-18 13:00:03 +01:00

761 lines
27 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 CreationDialog from '@/components/editor/annotations/CreationDialog'
import { drawnText } from '../helpers/editorFixtures'
import {
markRedraw,
resetWork,
setModePreview,
startMove,
startRedraw,
useAnnotationWork,
} from '@/editor/annotations/workStore'
import { emptyForm } from '@/editor/annotations/creation'
import {
placePending,
replacePoint,
traceVertex,
} from '@/editor/annotations/creationWork'
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(() => act(() => resetWork()))
const tabShown = () => screen.getByRole('tab', { selected: true })
// In act: « Refaire » now follows a started mode (final review I-1) and re-renders.
const started = () =>
act(() => {
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()
})
})
/**
* U2 Task 7 (R-12, A12): every guard site asks during a creation, and for a move mode or a
* redraw once work has started; with nothing started a mode ends at once.
*/
describe('the drawing guard at every site: creation, move, redraw', () => {
const STORED = { type: 'circle' as const, cx: 1, cy: 2, r: 3 }
afterEach(() => act(() => resetWork()))
const tabShown = () => screen.getByRole('tab', { selected: true })
const start = {
viewId: 'v',
frame: null,
origin: 'tool' as const,
form: emptyForm({ categories: [] } as never),
}
const point = {
kind: 'point' as const,
geometry: { type: 'circle' as const, cx: 5, cy: 5, r: 2 },
}
const WORK = {
// A point being replaced: no dialog, nothing typed, still asked (A12).
creation: () => {
placePending(start, point)
replacePoint()
},
tracing: () => traceVertex(start, 'zone', [1, 1]),
move: () => {
startMove('a', 'doc')
setModePreview({ ...STORED, cx: 9 }, STORED)
},
redraw: () => {
startRedraw('a', 'doc')
markRedraw(true)
},
}
const TITLE = {
creation: 'Abandonner la création ?',
tracing: 'Abandonner la création ?',
move: 'Abandonner le déplacement ?',
redraw: 'Abandonner le nouveau tracé ?',
}
const left = () => {
const work = useAnnotationWork.getState()
return work.creation === null && work.mode === null
}
type Kind = keyof typeof WORK
const kinds = Object.keys(WORK) as Kind[]
async function asks(kind: Kind, run: () => Promise<void>) {
const user = userEvent.setup()
await run()
const dialog = screen.getByRole('dialog', { name: TITLE[kind] })
await user.click(within(dialog).getByRole('button', { name: 'Continuer' }))
expect(left()).toBe(false)
return user
}
it.each(kinds)(
'%s: a tab click asks; « Continuer » keeps, « Abandonner » goes',
async (kind) => {
useLocaleStore.setState({ locale: 'fr' })
mount()
act(() => WORK[kind]())
const user = await asks(kind, () =>
userEvent.setup().click(screen.getByRole('tab', { name: 'Constats' })),
)
expect(tabShown()).toHaveTextContent('Général')
await user.click(screen.getByRole('tab', { name: 'Constats' }))
await user.click(screen.getByRole('button', { name: 'Abandonner' }))
expect(tabShown()).toHaveTextContent('Constats')
expect(left()).toBe(true)
},
)
it.each(kinds)(
'%s: an arrow-key tab move asks the same way',
async (kind) => {
useLocaleStore.setState({ locale: 'fr' })
mount()
const general = screen.getByRole('tab', { name: 'Général' })
act(() => general.focus())
act(() => WORK[kind]())
await asks(kind, async () => {
fireEvent.keyDown(general, { key: 'ArrowRight' })
})
expect(tabShown()).toHaveTextContent('Général')
},
)
it.each(kinds)('%s: a section entry asks the same way', async (kind) => {
useLocaleStore.setState({ locale: 'fr' })
mount()
act(() => WORK[kind]())
const user = await asks(kind, () =>
userEvent.setup().click(screen.getByRole('button', { name: 'section' })),
)
await user.click(screen.getByRole('button', { name: 'section' }))
await user.click(screen.getByRole('button', { name: 'Abandonner' }))
expect(left()).toBe(true)
})
it.each(kinds)('%s: a Back asks and keeps the view', async (kind) => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
await user.click(screen.getByRole('tab', { name: 'Constats' }))
act(() => WORK[kind]())
act(() => navigate(-1))
expect(tabShown()).toHaveTextContent('Constats')
await user.click(
within(screen.getByRole('dialog', { name: TITLE[kind] })).getByRole(
'button',
{ name: 'Abandonner' },
),
)
expect(left()).toBe(true)
})
it.each(['move', 'redraw'] as const)(
'%s with nothing started: tab, arrow key and section act at once',
async (kind) => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
mount()
const begin = () =>
kind === 'move' ? startMove('a', 'doc') : startRedraw('a', 'doc')
act(() => begin())
const general = screen.getByRole('tab', { name: 'Général' })
act(() => general.focus())
fireEvent.keyDown(general, { key: 'ArrowRight' })
expect(tabShown()).not.toHaveTextContent('Général')
expect(useAnnotationWork.getState().mode).toBeNull()
act(() => begin())
await user.click(screen.getByRole('button', { name: 'section' }))
expect(useAnnotationWork.getState().mode).toBeNull()
expect(screen.queryByRole('dialog')).toBeNull()
},
)
})
/**
* U2 Task 7: the creation dialog is a modal without a history layer. A Back while it is
* open is refused as a modal (the real `dialog[open]` of happy-dom), and its « Abandonner la
* création ? » shows inside it: without the modal branch's guard call this test fails.
*/
describe('a Back on the creation dialog', () => {
afterEach(() => act(() => resetWork()))
const doc = JSON.parse(drawnText())
function CreationPage() {
const nav = useEditorNavigation('annotations')
navigate = useNavigate()
location = useLocation()
useEditorHistory(nav, owner, defaultView('annotations'))
return (
<>
<EditorTabs
active={nav.state.tab}
tier="wide"
onSelect={nav.selectTab}
/>
<CreationDialog doc={doc} readOnly={false} anchor={{ current: null }} />
<DrawingGuardDialog />
</>
)
}
it('with nothing typed it asks inside the dialog; « Continuer » keeps the shape', async () => {
useLocaleStore.setState({ locale: 'fr' })
const user = userEvent.setup()
render(
<MemoryRouter initialEntries={['/x']}>
<CreationPage />
</MemoryRouter>,
)
// An entry of this editor to go Back to.
await user.click(screen.getByRole('tab', { name: 'Constats' }))
act(() =>
placePending(
{
viewId: 'view-main',
frame: null,
origin: 'tool',
form: emptyForm(doc),
},
{ kind: 'point', geometry: { type: 'circle', cx: 50, cy: 50, r: 5 } },
),
)
const dialog = await screen.findByRole('dialog', { name: 'Nouveau point' })
act(() => navigate(-1))
const ask = within(dialog).getByRole('group', {
name: 'Abandonner la création ?',
})
// One question, inside the dialog: the workspace's own stays closed.
expect(screen.getAllByRole('dialog')).toHaveLength(1)
await user.click(within(ask).getByRole('button', { name: 'Continuer' }))
expect(useAnnotationWork.getState().creation).not.toBeNull()
expect(
within(dialog).queryByRole('group', { name: /Abandonner/ }),
).toBeNull()
act(() => navigate(-1))
await user.click(within(dialog).getByRole('button', { name: 'Abandonner' }))
expect(useAnnotationWork.getState().creation).toBeNull()
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
})
})
/** U2 Task 6: the annotation properties dialog is a layer of the browser history. */
describe('the annotation layer and the history', () => {
function AnnotationPage({ dirty }: { dirty: boolean }) {
const nav = useEditorNavigation('annotations')
navigate = useNavigate()
location = useLocation()
useEditorHistory(nav, owner, defaultView('annotations'))
return (
<>
<button onClick={() => nav.openAnnotation('a1')}>open</button>
<button onClick={() => nav.closeAnnotation()}>close</button>
<button
onClick={() =>
nav.guards.register('annotation', () =>
dirty ? { allowed: false } : { allowed: true },
)
}
>
guard
</button>
<p data-testid="layer">{JSON.stringify(nav.state.annotation)}</p>
</>
)
}
const layer = () => JSON.parse(screen.getByTestId('layer').textContent!)
const mountPage = (dirty = false) =>
render(
<MemoryRouter initialEntries={['/x']}>
<AnnotationPage dirty={dirty} />
</MemoryRouter>,
)
it('opening pushes; Back closes it, Forward opens it again', async () => {
const user = userEvent.setup()
mountPage()
await user.click(screen.getByRole('button', { name: 'open' }))
expect(layer()).toEqual({ id: 'a1' })
expect(entry().view.annotation).toEqual({ id: 'a1' })
expect(entry().below?.annotation).toBeNull()
act(() => navigate(-1))
expect(layer()).toBeNull()
act(() => navigate(1))
expect(layer()).toEqual({ id: 'a1' })
})
it('a user close goes back to the drawing entry below', async () => {
const user = userEvent.setup()
mountPage()
await user.click(screen.getByRole('button', { name: 'open' }))
await user.click(screen.getByRole('button', { name: 'close' }))
await waitFor(() => expect(entry().view.annotation).toBeNull())
expect(layer()).toBeNull()
})
it('a dirty form keeps the dialog on a Back: its view is pushed again', async () => {
const user = userEvent.setup()
mountPage(true)
await user.click(screen.getByRole('button', { name: 'guard' }))
await user.click(screen.getByRole('button', { name: 'open' }))
act(() => navigate(-1))
expect(layer()).toEqual({ id: 'a1' })
expect(entry().view.annotation).toEqual({ id: 'a1' })
})
})