Files
faunosteo/apps/app/tests/unit/editor-annotation-dialog.test.tsx
T
bchanot ebcf2723a0 fix(editor): overview rows ask first, no empty save, board 31 icons
U2 Task 6 review by self:

- The overview stays shown during a selection (A3): its rows and view
  rows now go through the drawing guard, so a started move or redraw
  asks before a click there drops it (R-12). Was a regression: the
  column was unreachable while selected before Task 6.
- The edit form compares and merges trimmed names and colour: a space
  typed alone is no change and writes no `update`.
- A layer opened with no opener (reload, Forward) returns the focus
  to its row on close.
- Board 31 A: icons on « Modifier », « Modifier la forme » (the
  shape's glyph), « Marquer comme relu »; « Supprimer » as red text
  with its trash icon.
- Tests: overview row and view row ask during a started move; a row
  asks during a started redraw; whitespace-only save; unnamed link
  read rows; focus back to the row with no opener. Dead helpers
  removed (tests/helpers openProperties, e2e propertiesDialog).

Mapping: the point-edit « Enter on the selected row … asks first »
test (which replaced « Toutes les annotations asks first ») keeps its
place; the overview-row path it did not cover now has its own test.
2026-11-17 22:17:20 +01:00

566 lines
19 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
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')
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('« 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 text = insert(drawnText(), {
kind: 'annotation',
value: zone('z', { color: '#aa0000' }),
})
const regions = JSON.parse(text)
const code = regions.vertebral_config.regions[0]?.code ?? null
const value = zone('z', {
color: '#aa0000',
vertebral_region_code: code,
} as Partial<Annotation>)
await mount(insert(drawnText(), { kind: 'annotation', value } as never))
await selectRow('z')
await openProperties()
expect(rows()).toContain('Couleur')
if (code !== null) expect(rows()).toContain('Région vertébrale')
expect(within(dialog()!).getByText('#aa0000')).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(drawnText(), 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
const other = [...category.options].find((o) => !o.selected)
if (other) await user.selectOptions(category, other.value)
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' })
if (other) expect(annotationOf('a').category_id).toBe(other.value)
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('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")
})
})