Files
faunosteo/apps/app/tests/unit/editor-history-guards.test.tsx
T
bchanot 4d2c64f57f feat(editor): creation on the drawing then the creation dialog
U2 Task 7 (A2, A4, A5, A7, A12, A15; R-3, R-4, R-12, R-13, R-14).
The work store's `creation` owns the new shape, its form, its view and
F: a click with the point tool, a closed tracing or a keyboard
« Ajouter … » opens « Nouveau point / zone / accès », a modal without
a history layer over the right column, mounted beside EditOnly so a
read-only flip keeps it (« Créer », « Replacer », « Reprendre » off).
A new zone or link is a creation from its first vertex. The ghost
takes the form's category colour; the point tool previews under a
mouse; the canvas carries data-creating (other markers dimmed,
unselectable). « Replacer le point » / « Reprendre le tracé » hide the
dialog and keep the form; the strip offers « Revenir aux propriétés »,
« Retirer le dernier sommet », « Abandonner ». « Créer »: one insert,
tool back to « Sélectionner », the new element selected, « Point
créé · Défaire », focus on its row. ✕, Échap, « Abandonner » and Back
always ask « Abandonner la création ? » (DiscardConfirm inside the
dialog; DrawingGuardDialog elsewhere); answerDrawing drops the
creation. Undo, its shortcuts and the line's « Défaire » are inactive
during a creation. missingFields replaces formProblem (MissingSummary
shared with the edit form); the C26 notice has no numbers.
CreationPanel, formProblem, withGeometry and the keys required.fields,
required.names and create_cancel are gone; GeometryGroup is imported
by RepairDialog only.

Removed or rewritten assertions:
- tab « holds a point at the frame centre »: « Centre x » = 50 ->
  the ghost circle cx = 50; plus tool back to Sélectionner, « Point
  créé », one undo step.
- tab « refuses a creation without laterality »: the general line
  « Choisissez la catégorie et la latéralité » -> only « Choisissez
  une latéralité. » and « À compléter : Latéralité. », focus on it.
- tab « applies the geometry group to a pending zone »: removed (A8,
  no coordinate field) -> « places a triangle at the centre: the ghost
  shows it, Créer inserts it »; vertex edits after Créer are the e2e
  keyboard test.
- tab C26 « proposes C »: « x = 15, y = 15 » in the notice -> the R-4
  text, the notice inside the dialog; cancel test « Centre x » = 0 ->
  ghost cx = 0.
- tab « offers the correction when the core refuses a pending point »
  (typed cx 98): removed, no typed coordinate is possible; the verdict
  path stays covered by the C26 click tests and correctionFor units.
- tab H5 « a typed radius shows the core issue »: removed (A8); the
  size refusal is the slider's (Task 4 tests).
- tab H6 « a second click moves the pending point »: -> « Replacer le
  point », then the click moves the ghost, the form kept.
- tab H7 « Centre x/y » = 30/50 -> ghost cx/cy.
- tab tracing Enter: « x du sommet 3 » -> ghost points; « drops the
  tracing on Escape » -> Escape asks first (board 32 row 3), Continuer
  keeps, Abandonner drops; new « Annuler le tracé acts at once ».
- keep-alive « a pending creation is kept and focused » and « a
  tracing … is kept and focused »: the tab now asks first (R-12) ->
  « Continuer » keeps the tracing / the form, « Abandonner » goes.
- sections « its panel takes the focus » -> its dialog's
  [data-creation-focus] takes it.
- no-loss « pending creation with its name » (hidden with the body) ->
  the dialog stays across the crossing, read-only, Créer off (R-14).
- point-edit A5 « Rayon » = 7 / 9 -> ghost r = 7 / 9.
- e2e editor-annotations keyboard test « numeric position » (cx field
  250) -> UX_TESTS Keyboard: zone added, vertex added and removed,
  moved by the move mode, validated, saved. The « Fermer le tracé »
  step runs under expectNoShift again (shortcut removed).
- e2e editor-geometry C26: the proposed x, y read from the notice
  text -> from the overlay's correction circle; the R-4 text checked
  in the dialog.
- e2e editor-deselect « Escape cancels the tracing only » -> Escape
  asks, « Abandonner » cancels it, the selection kept.
- e2e editor-shell-crossing « keeps its tool and its pending
  creation » (field hidden) -> the dialog stays read-only, Créer off,
  then editable on widening.
2026-11-17 23:32:42 +01:00

760 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(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()
})
})
/**
* 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, and its « Abandonner la création ? » shows inside it. (Under happy-dom
* the refusal is reached through the drawing guard; the browser's modal branch is proved
* by the e2e in editor-annotations.spec.ts.)
*/
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' })
})
})