Files
faunosteo/apps/app/tests/unit/editor-annotation-dialog.test.tsx
T
bchanot 9a0fe3784c fix(editor): veil ignores clicks, names merged apart, honest tests
U2 Task 6 fix round 1 (review minors 1 to 9).

- R-6: `Dialog` takes `veilCloses`; the annotation dialog passes false,
  so its veil ignores clicks centred too. Other dialogs unchanged.
- Save merges each name on its own (an EN refreshed meanwhile survives
  an FR-only edit); the merged annotation is typed per kind, no cast.
- Tests: the category change and the region row really run (a second
  category and a region in the fixture); EN kept under an FR edit;
  focus to the drawing when a filter hides the row; a centred veil
  ignores a click; act() around the store write; ui.Dialog restores
  innerHeight and visualViewport after each test.
- e2e: `pickAnnotation` no longer scrolls; `scrollToTop` is explicit
  where a low row leaves the drawing out of view (editor-zones x3,
  editor-geometry). editor-geometry runs the accepted repair from the
  page's end, buttons pressed in place, scroll unchanged. The touch
  and double-click tests wait on the clicks themselves; the stray
  click on the veil can fail.
- CreationPanel's `required.fields` recorded as a shortcut for Task 7;
  TODO lines updated. focusTarget comment wrapped.
2026-11-17 22:47:02 +01:00

633 lines
22 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.
/** U2 Task 6: the properties dialog over the column (A1, A2, A3, A9, A10, R-3, R-14, R-16). */
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
act,
cleanup,
fireEvent,
render,
screen,
waitFor,
within,
} from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import type { Annotation, Point } from '@faunosteo/core-wasm/types'
import { resetWork, useAnnotationWork } from '@/editor/annotations/workStore'
import { useLocaleStore } from '@/state/localeStore'
import { LayeredTab, layered } from '../helpers/annotationLayer'
import { drawnText, insert, point } from '../helpers/editorFixtures'
import { openReady, pressAt, resetStore, store } from '../helpers/editorHarness'
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(),
}))
const props = {
navigate: vi.fn(),
reloadSheet: vi.fn(),
section: 'drawing' as const,
visited: ['drawing'] as const,
onOpenSection: vi.fn(),
onBack: vi.fn(),
}
const SQUARE: Point[] = [
[20, 20],
[80, 20],
[80, 80],
[20, 80],
]
const annotationOf = (id: string) =>
store
.getState()
.previewState!.document.annotations.find((a: Annotation) => a.id === id)!
const depth = () => store.getState().undo.length
const zone = (id: string, patch: Partial<Annotation> = {}): Annotation =>
({
...(point(id, 0, 0, 1).value as Annotation),
kind: 'zone',
geometry: { type: 'polygon', points: SQUARE },
...patch,
}) as Annotation
/** The drawn sheet with a second category `cat-b` and the region `C`. */
function richText(): string {
const both = insert(drawnText(), {
kind: 'category',
value: { id: 'cat-b', name: { fr: 'Os', en: 'Bone' }, color: null },
})
return insert(both, {
kind: 'region',
value: {
code: 'C',
name: { fr: 'Cervicales', en: 'Cervical' },
count: 7,
count_range: null,
},
})
}
function stubCtm(): void {
const identity = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }
Object.defineProperty(window.SVGElement.prototype, 'getScreenCTM', {
configurable: true,
value: () => ({ ...identity, inverse: () => identity }),
})
}
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
stubCtm()
})
afterEach(() => {
cleanup()
resetStore()
resetWork()
window.innerWidth = 1024
})
const tab = (readOnly = false) => (
<div data-editor-workspace>
<LayeredTab {...props} readOnly={readOnly} />
</div>
)
async function mount(text: string, readOnly = false) {
await openReady({ text })
const view = render(tab(readOnly))
const drawing = readOnly
? 'catalogue-canvas-drawing'
: 'annotation-canvas-drawing'
await waitFor(() =>
expect(screen.getByTestId(drawing).querySelector('svg')).not.toBeNull(),
)
return view
}
const rowOf = (id: string) =>
document.querySelector<HTMLElement>(
`[data-focus-key='{"kind":"annotation","id":"${id}"}']`,
)!
const strip = () => screen.getByTestId('edit-strip')
const dialog = () => screen.queryByRole('dialog')
const live = () => screen.getByTestId('live-region')
const marker = (id: string) =>
screen
.getByTestId('annotation-canvas-drawing')
.querySelector(`[data-anno-id="${id}"]`)!
async function selectRow(id: string) {
await userEvent.setup().click(rowOf(id))
await within(strip()).findByRole('button', { name: 'Propriétés' })
}
async function openProperties() {
await userEvent
.setup()
.click(within(strip()).getByRole('button', { name: 'Propriétés' }))
return screen.findByRole('dialog')
}
async function startEdit() {
const opened = await openProperties()
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Modifier' }))
return opened
}
const field = (label: string) =>
within(dialog()!).getByLabelText(label) as HTMLInputElement
describe('opening (A1)', () => {
it('a first click and Enter on a row only select; Enter on the selected row opens', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
expect(dialog()).toBeNull()
expect(rowOf('a')).toHaveAttribute('aria-current', 'true')
fireEvent.keyDown(rowOf('a'), { key: 'Enter', repeat: true })
expect(dialog()).toBeNull()
fireEvent.keyDown(rowOf('a'), { key: 'Enter' })
expect(await screen.findByRole('dialog', { name: 'N' })).toBeVisible()
})
it('a second click on the interior opens; with a chosen vertex it unchooses only', async () => {
await mount(insert(drawnText(), { kind: 'annotation', value: zone('z') }))
await selectRow('z')
act(() =>
useAnnotationWork.setState({
chosen: {
annotationId: 'z',
vertex: 1,
base: store.getState().documentText,
},
}),
)
pressAt(marker('z'), 50, 50)
expect(useAnnotationWork.getState().chosen).toBeNull()
expect(dialog()).toBeNull()
await new Promise((resolve) => setTimeout(resolve, 450))
pressAt(marker('z'), 50, 50)
expect(await screen.findByRole('dialog')).toBeVisible()
})
it('closed, the focus goes to the drawing when a filter hides the row (board 32)', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
fireEvent.change(screen.getByLabelText('Filtrer par nom'), {
target: { value: 'zzz-no-match' },
})
fireEvent.keyDown(document.body, { key: 'Escape' })
pressAt(marker('a'), 50, 50)
await within(strip()).findByRole('button', { name: 'Propriétés' })
await new Promise((resolve) => setTimeout(resolve, 450))
pressAt(marker('a'), 50, 50)
const opened = await screen.findByRole('dialog')
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Fermer' }))
await waitFor(() => expect(dialog()).toBeNull())
await waitFor(() =>
expect(document.activeElement).toBe(
screen.getByTestId('annotation-canvas'),
),
)
})
it('centred (below 1 024 px), its veil ignores a click too (R-6)', async () => {
window.innerWidth = 900
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await openProperties()
expect(screen.getByTestId('dialog-panel').style.left).toBe('')
await userEvent.setup().click(screen.getByTestId('dialog-backdrop'))
expect(dialog()).not.toBeNull()
})
it('« Propriétés » opens it; ✕ closes it and the focus goes back to the button', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
const opened = await openProperties()
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Fermer' }))
await waitFor(() => expect(dialog()).toBeNull())
await waitFor(() =>
expect(document.activeElement).toBe(
within(strip()).getByRole('button', { name: 'Propriétés' }),
),
)
// The selection stays after the close.
expect(rowOf('a')).toHaveAttribute('aria-current', 'true')
})
})
describe('the read mode (board 31 A, B)', () => {
const rows = () =>
within(dialog()!)
.getAllByRole('term')
.map((term) => term.textContent)
it('a point: names, category, laterality, findings zone and view; no colour, no region', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await openProperties()
expect(rows()).toEqual([
'Nom (FR)',
'Nom (EN)',
'Catégorie',
'Latéralité',
'Zone de constats',
'Vue',
])
expect(within(dialog()!).getByTestId('annotation-read')).toHaveTextContent(
'Point',
)
})
it('a zone with its own colour and a region shows both', async () => {
const value = zone('z', {
color: '#aa0000',
vertebral_region_code: 'C',
} as Partial<Annotation>)
await mount(insert(richText(), { kind: 'annotation', value } as never))
await selectRow('z')
await openProperties()
expect(rows()).toContain('Couleur')
expect(rows()).toContain('Région vertébrale')
expect(within(dialog()!).getByText('#aa0000')).toBeInTheDocument()
expect(within(dialog()!).getByText('Cervicales')).toBeInTheDocument()
})
it('an unnamed link: its opened view, « Vue ouverte », no findings zone', async () => {
const detail = insert(drawnText(), {
kind: 'view',
value: {
kind: 'detail',
id: 'view-det',
name: { fr: 'Tête', en: 'Head' },
svg_asset_id: null,
view_box: { min_x: 10, min_y: 10, width: 80, height: 80 },
parent_view_id: 'view-main',
},
})
const link = {
id: 'link-a',
view_id: 'view-main',
category_id: 'cat-a',
laterality: 'unpaired',
geometry: { type: 'circle', cx: 90, cy: 90, r: 3 },
review_status: 'to_confirm',
color: null,
kind: 'detail_trigger',
name: null,
opens_view_id: 'view-det',
} as Annotation
await mount(insert(detail, { kind: 'annotation', value: link }))
await selectRow('link-a')
const opened = await openProperties()
expect(rows()).toEqual([
'Nom (FR)',
'Nom (EN)',
'Catégorie',
'Latéralité',
'Vue ouverte',
'Vue',
])
expect(within(opened).getByTestId('annotation-read')).toHaveTextContent(
'Accès',
)
expect(within(opened).getAllByText('Tête').length).toBeGreaterThan(0)
})
it('« Marquer comme relu » is one change and one undo (A10)', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
const opened = await openProperties()
const before = depth()
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Marquer comme relu' }))
expect(annotationOf('a').review_status).toBe('reviewed')
expect(depth()).toBe(before + 1)
expect(
within(opened).getByRole('button', { name: 'Remettre à confirmer' }),
).toBeInTheDocument()
act(() => void store.getState().undoStep())
expect(annotationOf('a').review_status).toBe('to_confirm')
})
it('the issues block names the inherited out-of-frame point', async () => {
await mount(insert(drawnText(), point('a', 150, 150, 5)))
await selectRow('a')
const opened = await openProperties()
expect(
within(opened).getByTestId('annotation-geometry-issues'),
).toHaveAttribute('role', 'alert')
})
it('« Modifier la forme » closes it, keeps the selection, focuses the first handle', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
const opened = await openProperties()
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Modifier la forme' }))
await waitFor(() => expect(dialog()).toBeNull())
await waitFor(() =>
expect(document.activeElement).toBe(screen.getByTestId('point-handle')),
)
expect(rowOf('a')).toHaveAttribute('aria-current', 'true')
})
})
describe('the edit form (board 31 C, R-3)', () => {
it('category and both names saved: ONE history entry, the read mode back', async () => {
await mount(insert(richText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
const before = depth()
await user.clear(field('Nom (FR)'))
await user.type(field('Nom (FR)'), 'Grasset')
await user.clear(field('Nom (EN)'))
await user.type(field('Nom (EN)'), 'Stifle')
const category = within(dialog()!).getByLabelText(
'Catégorie',
) as HTMLSelectElement
await user.selectOptions(category, 'cat-b')
expect(depth()).toBe(before)
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(depth()).toBe(before + 1)
expect(annotationOf('a').name).toEqual({ fr: 'Grasset', en: 'Stifle' })
expect(annotationOf('a').category_id).toBe('cat-b')
expect(
within(dialog()!).getByText('Modifications enregistrées'),
).toBeInTheDocument()
})
it('the save merges onto the current annotation: a move made meanwhile stays', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
await user.type(field('Nom (FR)'), 'x')
const moved = {
...annotationOf('a'),
geometry: { type: 'circle', cx: 40, cy: 50, r: 5 },
}
act(
() =>
void store.getState().commit({
op: 'update',
key: { kind: 'annotation', id: 'a' },
element: { kind: 'annotation', value: moved as Annotation },
}),
)
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(annotationOf('a').geometry).toMatchObject({ cx: 40 })
expect(annotationOf('a').name?.fr).toBe('Nx')
})
it('editing FR only keeps an EN changed meanwhile (each name merged on its own)', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
await user.type(field('Nom (FR)'), 'x')
const renamed = { ...annotationOf('a'), name: { fr: 'N', en: 'Fresh' } }
act(
() =>
void store.getState().commit({
op: 'update',
key: { kind: 'annotation', id: 'a' },
element: { kind: 'annotation', value: renamed as Annotation },
}),
)
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(annotationOf('a').name).toEqual({ fr: 'Nx', en: 'Fresh' })
})
it('a blank name: named under its field and in the summary, focused, nothing written', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
const before = store.getState().documentText
await user.clear(field('Nom (EN)'))
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(
within(dialog()!).getByText('Saisissez le nom en anglais.'),
).toBeInTheDocument()
expect(
within(dialog()!).getByText('À compléter : Nom (EN).'),
).toHaveAttribute('role', 'alert')
expect(within(dialog()!).queryByText(/Choisissez/)).toBeNull()
expect(document.activeElement).toBe(field('Nom (EN)'))
expect(store.getState().documentText).toBe(before)
})
it('a space typed and nothing else: no change, no history entry', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
const before = depth()
await user.type(field('Nom (FR)'), ' ')
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(depth()).toBe(before)
expect(
within(dialog()!).getByRole('button', { name: 'Modifier' }),
).toBeInTheDocument()
})
it('« Annuler » with changes asks; « Abandonner » writes nothing', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
const before = store.getState().documentText
await user.type(field('Nom (FR)'), 'x')
await user.click(within(dialog()!).getByRole('button', { name: 'Annuler' }))
expect(
within(dialog()!).getByText('Abandonner les modifications ?'),
).toBeInTheDocument()
await user.click(
within(dialog()!).getByRole('button', { name: 'Abandonner' }),
)
expect(store.getState().documentText).toBe(before)
expect(
within(dialog()!).getByRole('button', { name: 'Modifier' }),
).toBeInTheDocument()
})
it('« Couleur » sits in the form with the category’s placeholder (A9)', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
expect(field('Couleur')).toHaveAttribute(
'placeholder',
'Celle de la catégorie',
)
})
})
describe('a read-only flip (R-14, Review Focus 3)', () => {
it('the dialog stays with its draft, read-only, nothing committed; editable on the way back', async () => {
const view = await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await startEdit()
const user = userEvent.setup()
await user.type(field('Nom (FR)'), 'x')
const before = store.getState().documentText
view.rerender(tab(true))
expect(dialog()).not.toBeNull()
expect(field('Nom (FR)')).toHaveValue('Nx')
expect(field('Nom (FR)')).toHaveAttribute('readonly')
expect(within(dialog()!).getByLabelText('Catégorie')).toBeDisabled()
expect(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
).toBeDisabled()
expect(store.getState().documentText).toBe(before)
view.rerender(tab(false))
expect(field('Nom (FR)')).toHaveValue('Nx')
expect(field('Nom (FR)')).not.toHaveAttribute('readonly')
await user.click(
within(dialog()!).getByRole('button', { name: 'Enregistrer' }),
)
expect(annotationOf('a').name?.fr).toBe('Nx')
})
it('a started move mode is suspended and resumes with its position', async () => {
const view = await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
const user = userEvent.setup()
await user.click(screen.getByRole('button', { name: 'Déplacer le point' }))
fireEvent.click(
screen.getByRole('button', { name: 'Déplacer vers la droite' }),
)
view.rerender(tab(true))
expect(useAnnotationWork.getState().mode?.started).toBe(true)
view.rerender(tab(false))
await user.click(
screen.getByRole('button', { name: 'Valider la position' }),
)
expect(annotationOf('a').geometry).toMatchObject({ cx: 50.5 })
})
})
describe('a read-only sheet at 1 024 px and wider (R-16)', () => {
it('the strip says « fiche en lecture seule »; « Propriétés » opens values only', async () => {
window.innerWidth = 1280
await mount(insert(drawnText(), point('a', 50, 50, 5)), true)
await userEvent.setup().click(rowOf('a'))
expect(
await within(strip()).findByTestId('edit-strip-detail'),
).toHaveTextContent('Point · fiche en lecture seule')
expect(screen.queryByTestId('point-handle')).toBeNull()
expect(screen.queryByTestId('size-slider')).toBeNull()
const opened = await openProperties()
expect(within(opened).getByTestId('annotation-read')).toBeInTheDocument()
expect(
within(opened).queryByRole('button', { name: 'Modifier' }),
).toBeNull()
expect(
within(opened).queryByRole('button', { name: 'Supprimer' }),
).toBeNull()
})
it('below 1 024 px the twin reads it inline, with no strip', async () => {
window.innerWidth = 800
await mount(insert(drawnText(), point('a', 50, 50, 5)), true)
await userEvent.setup().click(rowOf('a'))
expect(await screen.findByTestId('annotation-read')).toBeInTheDocument()
expect(screen.getByTestId('annotation-selection-tag')).toBeInTheDocument()
expect(screen.queryByTestId('edit-strip')).toBeNull()
})
})
describe('the layer (history)', () => {
it('an annotation that vanished closes the dialog and is said', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
await openProperties()
act(
() =>
void store
.getState()
.commit({ op: 'remove', key: { kind: 'annotation', id: 'a' } }),
)
await waitFor(() => expect(dialog()).toBeNull())
await waitFor(() =>
expect(live()).toHaveTextContent("Cette annotation n'existe plus"),
)
expect(layered.nav?.state.annotation).toBeNull()
})
it('a layer for an annotation of another view shows that view and selects it', async () => {
const detail = insert(drawnText(), {
kind: 'view',
value: {
kind: 'detail',
id: 'view-det',
name: { fr: 'Tête', en: 'Head' },
svg_asset_id: null,
view_box: { min_x: 10, min_y: 10, width: 80, height: 80 },
parent_view_id: 'view-main',
},
})
const text = insert(
insert(detail, point('a', 50, 50, 5)),
point('b', 40, 40, 5, 'view-det'),
)
await mount(text)
act(() => layered.nav!.openAnnotation('b'))
await waitFor(() =>
expect(rowOf('b')).toHaveAttribute('aria-current', 'true'),
)
expect(
screen.getByRole('button', { name: 'Tête', pressed: true }),
).toBeInTheDocument()
})
it('a layer opened with no opener (a Forward, a reload) returns the focus to its row', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
act(() => layered.nav!.openAnnotation('a'))
const opened = await screen.findByRole('dialog')
await userEvent
.setup()
.click(within(opened).getByRole('button', { name: 'Fermer' }))
await waitFor(() => expect(dialog()).toBeNull())
await waitFor(() => expect(document.activeElement).toBe(rowOf('a')))
})
it('a deletion from the dialog closes it, unsaid as a vanish', async () => {
await mount(insert(drawnText(), point('a', 50, 50, 5)))
await selectRow('a')
const opened = await openProperties()
const user = userEvent.setup()
await user.click(within(opened).getByRole('button', { name: 'Supprimer' }))
const ask = await screen.findByRole('dialog', { name: /Supprimer/ })
await user.click(within(ask).getByRole('button', { name: 'Supprimer' }))
await waitFor(() => expect(screen.queryAllByRole('dialog')).toHaveLength(0))
expect(live()).not.toHaveTextContent("n'existe plus")
})
})