Files
faunosteo/apps/app/tests/unit/editor-keep-alive.test.tsx
T
bchanot 4499bc740c feat(editor): fifth tab « Références », citations panel from a finding
The reference library moves into a fifth editor tab (Général,
Annotations, Constats, Références, Vérification; under « Plus » below
640 px with Général and Constats). The header « Références » button is
removed. The side panel becomes the citations list of one finding,
opened only from a finding's trigger (owner GO 2026-11-12: never from a
family; the family keeps its inline list with « Retirer »). Selecting a
tab closes it; every close records one pending move applied after the
panel is gone, focus back to the trigger else the active tab button.
Vérification's reference issues land on the tab. e2e seed gains a
reference cited by « Constat A ».

Gates: typecheck, lint, test:run (app 1396), build, e2e:ui 251 passed;
e2e:shell 15 specs on db:sandbox (editor-equine never listed): 107
passed / 95 skipped / 2 failed (test remap dropped its edit), fixed and
rerun: editor-shell.spec 11 passed; full-row data guard: no
pre-existing row changed in any table. editor-equine.spec.ts helper
calls updated, not run.

## R-24 table (removed or rewritten assertions; old = fc3fec7 line, new = current file)

Unit tests:

| file:old line | old | new |
|---|---|---|
| editor-verification.test.tsx:87-96 | `navigate` called with target AND `expect.any(HTMLElement)` | called with the target only (opener dropped) |
| editor-verification.test.tsx:238-241 | `references[0]` path -> `{place:'references', citedBy:null}` | `{place:'tab', tab:'references', section:null}` |
| editor-verification.test.tsx:262-264 | `placeKey(references[9])` = `editor.place.references` | `editor.tab.references` |
| editor-navigation.test.ts:63 | targetOfKey reference -> `{place:'references', key, citedBy:null}` | `{place:'tab', tab:'references', section:null, key}` |
| editor-navigation.test.ts:80 | `referencesMounted` false at start | `citationsOf` null and `libraryReset` 0 |
| editor-navigation.test.ts:95-110 | go_to a reference opens the panel over the place | go_to a reference shows the Références tab with its focus request |
| editor-navigation.test.ts:112-122 | go_to a tab closes the panel (`references` object) | same, via `citationsOf` null |
| editor-navigation.test.ts:124-136 | select_tab keeps the panel | select_tab CLOSES the panel (P21), keeps section, no request |
| editor-navigation.test.ts:138-146 | `clear_cited_by` drops the filter | removed (action gone); replaced by `open_citations` refuses family/zone/view, `show_all_references` (closes, tab, reset bump), plain go_to leaves reset alone |
| editor-navigation.test.ts:160-175 | open/close references keep tab and section | open/close citations, same assertions on `citationsOf` |
| editor-mode.test.ts:100-109 | tabsFor four tabs, small more = general, findings | five tabs, small more = general, findings, references |
| editor-route.test.tsx:46,50 | TABS four, title « four tabs » | five |
| editor-route.test.tsx:139-146 | 640-1023 px four tabs | five tabs, tablist has `flex-wrap` |
| editor-route.test.tsx:149-161 | « Plus » lists Général, Constats | lists Général, Constats, Références |
| editor-route.test.tsx:168-190 | header button opens panel, ✕ returns focus to button | no header button, panel not mounted at start (full panel flow moved to editor-references-panel.test.tsx) |
| editor-route.test.tsx:192-206 | Escape closes, panel content kept for next opening | removed: the panel is no longer kept mounted (design choice 3); Escape/close covered in editor-references-panel + editor-escape |
| editor-route.test.tsx:208-218 | read-only: panel lists references, no edit control | read-only: the Références tab lists them, no textbox, no add button; plus new: tab keeps mounted when left |
| editor-tabs-lists.test.tsx:47,75,114,130 | render `ReferencesPanel` | render `ReferencesTab` |
| editor-tabs-lists.test.tsx:77 | selector `#reference-ref-a-url` | `#tab-reference-ref-a-url` |
| editor-tabs-lists.test.tsx:131-135 | read-only buttons = only « Fermer les références » | no button at all |
| editor-focus-request.test.tsx:166-171,200-202,346 | `ReferencesPanel` with `panel` props and focus | `ReferenceLibrary` with focus (same assertions) |
| editor-focus-request.test.tsx:226 | `ownedBy(ref,'citations')` is the request | `ownedBy(ref,'references')` is the request, `'citations'` undefined |
| editor-focus-request.test.tsx (Probe) | none | new: Vérification « Aller à » reference -> tab + focused row; reference path naming no element -> tab heading |
| editor-keep-alive.test.tsx:71,178-190 | add form survives closing/reopening the panel | survives leaving/returning to the Références tab (`#tab-reference-new-citation`) |
| editor-keep-alive.test.tsx:300-326 | « Aller à » without focus move commits Références text | a tab click without focus move commits it (one undo entry): « Aller à » is not reachable from the Références tab in R2.1 |
| editor-keep-alive.test.tsx:333-347 | Escape in panel reference field commits, panel hides | same, panel opened from a finding node, field `#panel-reference-ref-1-citation` |
| editor-keep-alive.test.tsx:350-363 | header toggle (no focus move) closes after committing | scrim click (no focus move) closes after committing |
| editor-keep-alive.test.tsx:425 | `referencesButton` click in the all-places sweep | `Références` added to the tab loop |
| editor-escape.test.tsx:218-227 | header button toggle, Escape on body closes panel, annotation selection kept | trigger-opened panel (A5), Escape closes it, `aria-expanded` back to false, selection kept after returning to Annotations |
| editor-escape.test.tsx:255-266 | Escape from tab row closes panel | same from the Constats tab button |
| editor-no-loss.test.tsx:146-153 | reference creation form, in the panel | in the Références tab, id `tab-reference-new-citation` |
| editor-no-loss.test.tsx:285-291 | focused header button survives crossing | focused tab button (Constats) survives crossing: no header button left |
| editor-no-loss.test.tsx:293-307 | references search in panel keeps focus/text | same in the Références tab body |
| editor-no-loss.test.tsx:390-400 | `everyPlace` ends by opening the panel | visits Références in the tab loop, no panel open |
| editor-no-loss-decisions.test.tsx:248-259 | open references panel holds the decision back | REMOVED: the panel exists only over Constats, decisions live in Annotations (hidden then); « a widening on another tab opens nothing » (same file) covers the withholding |
| editor-route-recovery.test.tsx:93-97 | recovery offer: header button opens panel, `aria-labelledby` | tab Références shows `editor-tab-references` labelled by `editor-references-title` |
| editor-references-panel.test.tsx (all) | header-button-driven panel tests incl. search, order, add, « Aller à » | split: panel tests (finding path only) stay in this file; library tests moved to new editor-references-tab.test.tsx (search matching, ↑/↓ only without search, counts, Ctrl+Z, read-only, « Aller à », add clears search, refused add keeps it); new: reset signal, ids unique with both mounted (P14), P6 fallback under « Plus » |

e2e (updated only, not run):

| file:old line | old | new |
|---|---|---|
| editor-shell.spec.ts:95-108 | panel keeps form text, no id repeats | Références tab keeps form text (`#tab-reference-new-citation`), ids unique with the panel open |
| editor-shell.spec.ts:121-142 | open panel leaves header and tab row clickable (incl. header Références button, add form) | `openCitations`; header button target and form steps dropped |
| editor-shell-journeys.spec.ts:113-123 | four tabs, `old` list includes « Références » | five tabs, « Références » removed from the old-layout list |
| editor-shell-journeys.spec.ts:246-249 | Aller à reference -> panel visible, close | `place('references')` visible, tab Références selected, row focus key, no close |
| editor-shell-layout.spec.ts:84-103 | overflow on four tabs + panel over drawing | five tabs + `openCitations`/`closeCitations` |
| editor-shell-layout.spec.ts:54-63 | local `goToTab` | removed, uses `openTab` |
| editor-shell-layout.spec.ts:140-158 | canvas width without/with panel over the drawing | E1: width measured before open and after a P21 switch to Annotations, asserted equal |
| editor-shell-layout.spec.ts:161-189 | axe on four tabs + open panel | five tabs + citations panel |
| editor-shell-layout.spec.ts:~255-310 | keyboard order began with `header` (the Références button) | `header` dropped from both orders (no focusable header control while the draft is clean); panel test selects Annotations before walking to `side` |
| editor-access.spec.ts:150-152,191-194,219-220 | axe/overflow with the panel at 320/375/768/800, 1024, read-only | same checks through `openCitations` (`showDrawing` calls dropped) |
| editor-shell-crossing.spec.ts:194-206 | references form with panel open, tab `annotations` | in the tab, focus expected on `editor-tab-references` |
| editor-shell-crossing.spec.ts:264-282 | panel open + add-form text across crossing | citations panel over a crossing, no typed-text step |
| editor-shell-crossing.spec.ts:~385-410 | decision withheld while panel open, Reprendre | REMOVED (state unreachable, see unit row) |
| editor-deselect.spec.ts:226-229 | Escape closes header-opened panel, selection kept | opened via Constats, Escape, back to Annotations, selection kept |
| editor-structures.spec.ts:80-122 | two references added, counts 2/1 | shape now holds `ref-a`: counts 3/2, `nth(1)` after move, saved list `['Référence A','Seconde référence']`, no panel |
| editor-equine.spec.ts:304-305,404-405 | openReferences/closeReferences | `openTab(page, dict, 'references')`: mis à jour, non exécuté, non vérifié |

Fix round 1: 1. e2e/shell/editor-shell.spec.ts « the open citations panel leaves the header and the tab row clickable »: before `openCitations`, the test now opens the Références tab and adds a reference through the library form (`#tab-reference-new-type` book, `#tab-reference-new-citation` « Smith 1999 », « Ajouter la référence »), so the draft is dirty and Save is enabled. All original assertion
2026-11-12 20:29:27 +01:00

634 lines
22 KiB
TypeScript

/** U1 Lot B2a: tabs, Annotations sections and the Références tab stay mounted. */
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 { AnatomicalSheetDocument } from '@faunosteo/core-wasm/types'
import EditorTabBody from '@/components/editor/EditorTabBody'
import KeptPlace from '@/components/editor/KeptPlace'
import { useSheetDocument } from '@/editor/sheetDocument'
import { usePlaceVisible } from '@/lib/placeVisibility'
import { FocusConsumedContext } from '@/editor/focusRequest'
import { targetOfKey } from '@/editor/navigation'
import { useLocaleStore } from '@/state/localeStore'
import { cleanSvg } from '@/editor/core/cleaning'
import {
ASSET,
drawnText,
edit,
emptyText,
insert,
point,
} from '../helpers/editorFixtures'
import {
baseText,
resetStore,
sb,
serverHas,
store,
versionAnswer,
} from '../helpers/editorHarness'
import { mountDraft, setWidth } from '../helpers/editorRoute'
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(),
}))
beforeEach(() => {
useLocaleStore.setState({ locale: 'fr' })
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 }),
})
})
afterEach(() => {
cleanup()
resetStore()
setWidth(1024)
})
const ready = () =>
screen.findByRole('heading', { level: 1, name: 'Brouillon, version 4' })
const tab = (name: string | RegExp) => screen.getByRole('tab', { name })
const entry = (name: string | RegExp) => screen.getByRole('button', { name })
const place = (name: string) =>
document.querySelector<HTMLElement>(`[data-place="${name}"]`)!
const inPlace = (name: string) => within(place(name))
const name = (n: string) => ({ fr: n, en: n })
function findingsText(from = baseText(), nodeRefs?: string[]): string {
const text = insert(from, {
kind: 'zone',
value: { id: 'zone-a', name: name('Zone A'), categories: [] },
})
const family = edit(text, {
op: 'insert',
parent: { kind: 'zone', id: 'zone-a' },
element: {
kind: 'finding_category',
value: {
id: 'fcat-a',
kind: 'dysfunction',
name: name('Cat A'),
description: {},
reference_ids: [],
review_status: 'to_confirm',
children: [],
},
},
})
if (!nodeRefs) return family
return edit(family, {
op: 'insert',
parent: { kind: 'finding', zone_id: 'zone-a', path: ['fcat-a'] },
element: {
kind: 'finding_node',
value: {
id: 'fnode-a',
name: name('Node A'),
description: {},
reference_ids: nodeRefs,
requires_vet_referral: false,
review_status: 'to_confirm',
children: [],
},
},
})
}
function referenceText(): string {
return insert(baseText(), {
kind: 'reference',
value: {
id: 'ref-1',
type: 'journal',
citation: 'Doe 2020',
url: null,
doi: null,
},
})
}
/** Constats, the node selected, its « 1 référence » trigger pressed. */
async function openCitations(user: Awaited<ReturnType<typeof mount>>) {
await user.click(tab('Constats'))
await user.click(screen.getByRole('treeitem', { name: /Cat A/ }))
await user.keyboard('{ArrowRight}')
await user.click(screen.getByRole('treeitem', { name: /Node A/ }))
await user.click(screen.getByRole('button', { name: '1 référence' }))
}
async function mount(text = baseText()) {
serverHas(text, 3)
const user = userEvent.setup()
mountDraft()
await ready()
return user
}
describe('KeptPlace', () => {
function Probe() {
return <p>{usePlaceVisible() ? 'yes' : 'no'}</p>
}
it('hides its children and composes with the places around it', () => {
render(
<KeptPlace name="outer" visible>
<KeptPlace name="inner" visible={false}>
<Probe />
</KeptPlace>
<KeptPlace name="other" visible>
<Probe />
</KeptPlace>
</KeptPlace>,
)
expect(place('inner')).not.toBeVisible()
expect(place('other')).toBeVisible()
expect(screen.getAllByText('yes')).toHaveLength(1)
})
it('an own visible place inside a hidden one is not visible', () => {
render(
<KeptPlace name="outer" visible={false}>
<KeptPlace name="inner" visible>
<Probe />
</KeptPlace>
</KeptPlace>,
)
expect(screen.getByText('no')).toBeInTheDocument()
})
it('is visible outside any place', () => {
render(<Probe />)
expect(screen.getByText('yes')).toBeInTheDocument()
})
})
describe('text typed in a place that is left', () => {
it('the category add form survives Général ↔ Annotations and a section round trip', async () => {
const user = await mount()
await user.click(tab('Annotations'))
await user.click(entry('Modifier les catégories'))
const field = inPlace('annotations.categories').getByLabelText(
'Nom de la catégorie (FR)',
{ selector: '#category-new-fr' },
)
await user.type(field, 'Brouillon')
await user.click(tab('Général'))
expect(place('annotations.categories')).not.toBeVisible()
await user.click(tab('Annotations'))
expect(place('annotations.categories')).toBeVisible()
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await user.click(entry('Modifier les catégories'))
expect(document.querySelector('#category-new-fr')).toBe(field)
expect(field).toHaveValue('Brouillon')
expect(store.getState().unsaved).toBe(false)
})
it('the reference add form survives leaving and returning to the Références tab', async () => {
const user = await mount()
await user.click(tab('Références'))
const field = inPlace('references').getByLabelText('Citation', {
selector: '#tab-reference-new-citation',
})
await user.type(field, 'Smith 1999')
await user.click(tab('Annotations'))
expect(place('references')).not.toBeVisible()
await user.click(tab('Références'))
expect(field).toHaveValue('Smith 1999')
expect(store.getState().unsaved).toBe(false)
})
})
describe('findings and canvas state across a tab change', () => {
it('the findings selection and expansion survive', async () => {
const user = await mount(findingsText())
await user.click(tab('Constats'))
const zone = inPlace('findings').getByRole('treeitem', { name: /Zone A/ })
const cat = inPlace('findings').getByRole('treeitem', { name: /Cat A/ })
await user.click(cat)
expect(zone).toHaveAttribute('aria-expanded', 'true')
await user.click(tab('Général'))
await user.click(tab('Constats'))
expect(inPlace('findings').getByRole('treeitem', { name: /Cat A/ })).toBe(
cat,
)
expect(cat).toHaveAttribute('aria-selected', 'true')
expect(zone).toHaveAttribute('aria-expanded', 'true')
})
it('the canvas tool, selection and zoom survive a tab change and a section round trip', async () => {
const text = insert(drawnText(), point('anno-a', 50, 50, 5))
const user = await mount(text)
await waitFor(() =>
expect(
inPlace('annotations.drawing').getByRole('button', { name: 'Zone' }),
).toBeEnabled(),
)
const drawing = inPlace('annotations.drawing')
await user.click(drawing.getByRole('button', { name: 'Zone' }))
await user.click(drawing.getByRole('button', { name: 'Zoom avant' }))
const layer = () =>
drawing.getByTestId('annotation-canvas').firstElementChild as HTMLElement
const zoomed = layer().style.transform
expect(zoomed).not.toContain('scale(1)')
await user.click(tab('Général'))
await user.click(tab('Annotations'))
await user.click(entry('Gérer les vues'))
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
expect(drawing.getByRole('button', { name: 'Zone' })).toHaveAttribute(
'aria-pressed',
'true',
)
expect(layer().style.transform).toBe(zoomed)
const list = drawing.getByRole('list', { name: 'Annotations de la vue' })
await user.click(within(list).getAllByRole('button')[0])
const marker = () =>
drawing
.getByTestId('annotation-canvas-drawing')
.querySelector('[data-anno-id="anno-a"]')
const stillSelected = () =>
waitFor(() => expect(marker()).toHaveAttribute('data-state', 'current'))
await stillSelected()
await user.click(tab('Général'))
await user.click(tab('Annotations'))
await stillSelected()
expect(drawing.getByTestId('annotation-properties')).toBeVisible()
})
it('the unmeasured hint opens the views section and « Retour au dessin » restores the same canvas', async () => {
serverHas(emptyText(), 3, false)
const user = userEvent.setup()
mountDraft()
await ready()
await user.click(tab('Annotations'))
const drawing = inPlace('annotations.drawing')
const canvas = drawing.getByTestId('annotation-canvas')
await user.click(drawing.getByRole('button', { name: 'Vues' }))
expect(place('annotations.views')).toBeVisible()
expect(place('annotations.drawing')).not.toBeVisible()
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
expect(place('annotations.drawing')).toBeVisible()
expect(drawing.getByTestId('annotation-canvas')).toBe(canvas)
})
})
describe('a field still focused while a place is left', () => {
async function generalNameField(user: ReturnType<typeof userEvent.setup>) {
await user.click(tab('Général'))
const field = inPlace('general').getByLabelText('Nom (FR)', {
exact: true,
selector: '#general-name-fr',
})
await user.click(field)
fireEvent.change(field, { target: { value: 'Nom saisi' } })
return field
}
it('a click that moves no focus (Safari) still commits it, as one undo entry', async () => {
const user = await mount()
const before = store.getState().documentText
const field = await generalNameField(user)
expect(document.activeElement).toBe(field)
fireEvent.click(tab('Annotations'))
expect(JSON.parse(store.getState().documentText).name.fr).toBe('Nom saisi')
expect(store.getState().unsaved).toBe(true)
act(() => void store.getState().undoStep())
expect(store.getState().documentText).toBe(before)
})
it('an arrow key on the tab list commits it first, as one undo entry', async () => {
const user = await mount()
const before = store.getState().documentText
const field = await generalNameField(user)
fireEvent.keyDown(tab('Général'), { key: 'ArrowRight' })
expect(tab('Annotations')).toHaveAttribute('aria-selected', 'true')
expect(JSON.parse(store.getState().documentText).name.fr).toBe('Nom saisi')
expect(field).toHaveValue('Nom saisi')
expect(store.getState().unsaved).toBe(true)
act(() => void store.getState().undoStep())
expect(store.getState().documentText).toBe(before)
})
it('a tab click without a focus move commits the Références text, as one undo entry', async () => {
const user = await mount(referenceText())
const before = store.getState().documentText
await user.click(tab('Références'))
const field = inPlace('references').getByLabelText('Citation', {
selector: '#tab-reference-ref-1-citation',
})
await user.click(field)
fireEvent.change(field, { target: { value: 'Doe 2023' } })
fireEvent.click(tab(/Vérification/))
expect(
JSON.parse(store.getState().documentText).references[0].citation,
).toBe('Doe 2023')
expect(store.getState().unsaved).toBe(true)
expect(place('references')).not.toBeVisible()
act(() => void store.getState().undoStep())
expect(store.getState().documentText).toBe(before)
})
it('Escape in a citations panel field commits the text before the panel closes', async () => {
const user = await mount(findingsText(referenceText(), ['ref-1']))
await openCitations(user)
const field = inPlace('citations').getByLabelText('Citation', {
selector: '#panel-reference-ref-1-citation',
})
await user.click(field)
fireEvent.change(field, { target: { value: 'Doe 2021' } })
await user.keyboard('{Escape}')
expect(screen.queryByTestId('editor-citations-panel')).toBeNull()
const doc: AnatomicalSheetDocument = JSON.parse(
store.getState().documentText,
)
expect(doc.references[0].citation).toBe('Doe 2021')
expect(store.getState().unsaved).toBe(true)
})
it('the scrim (no focus move) closes the panel after committing', async () => {
const user = await mount(findingsText(referenceText(), ['ref-1']))
await openCitations(user)
const field = inPlace('citations').getByLabelText('Citation', {
selector: '#panel-reference-ref-1-citation',
})
await user.click(field)
fireEvent.change(field, { target: { value: 'Doe 2022' } })
fireEvent.click(screen.getByTestId('references-scrim'))
expect(screen.queryByTestId('editor-citations-panel')).toBeNull()
expect(
JSON.parse(store.getState().documentText).references[0].citation,
).toBe('Doe 2022')
})
})
describe('ids and parses', () => {
const detail = {
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: 20, width: 40, height: 60 },
parent_view_id: 'view-main',
},
} as const
/** A drawing whose own elements carry ids, so a second composed copy would repeat them. */
function serveDrawingWithIds(text: string): void {
const svg =
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">' +
'<defs><linearGradient id="fade"><stop offset="0"/></linearGradient></defs>' +
'<rect id="body" width="4" height="4" fill="url(#fade)"/></svg>'
const cleaned = cleanSvg(new TextEncoder().encode(svg))
if (!cleaned.ok || !cleaned.value.stored) throw new Error('uncleanable')
const bytes = new TextEncoder().encode(cleaned.value.stored)
const answer = versionAnswer(text, 3)
answer.drawings = [{ asset_id: ASSET, sha256: cleaned.value.sha256! }]
sb.getSheetVersion.mockResolvedValue(answer as never)
sb.downloadSheetDrawing.mockResolvedValue(bytes)
}
const composedHosts = () =>
[
...document.querySelectorAll(
'[data-testid="annotation-canvas-drawing"], [data-testid="crop-canvas-drawing"]',
),
].filter((host) => host.querySelector('svg'))
it('every place visited, a crop group open: one composed copy, no id repeats', async () => {
serveDrawingWithIds(insert(drawnText(), detail))
const user = userEvent.setup()
mountDraft()
await ready()
await waitFor(() => expect(composedHosts()).toHaveLength(1))
await user.click(entry('Gérer les vues'))
await user.click(
inPlace('annotations.views').getByRole('button', {
name: 'Modifier le recadrage',
}),
)
await waitFor(() => expect(composedHosts()).toHaveLength(1))
expect(composedHosts()[0]).toHaveAttribute(
'data-testid',
'crop-canvas-drawing',
)
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await user.click(entry('Modifier les catégories'))
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await user.click(entry(/^Régions vertébrales/))
for (const name of ['Général', 'Constats', 'Références', /Vérification/]) {
await user.click(tab(name))
}
expect(composedHosts()).toHaveLength(0)
await user.click(tab('Annotations'))
await user.click(screen.getByRole('button', { name: 'Retour au dessin' }))
await waitFor(() => expect(composedHosts()).toHaveLength(1))
const ids = [...document.querySelectorAll('[id]')].map((e) => e.id)
expect(ids.filter((id, i) => ids.indexOf(id) !== i)).toEqual([])
expect(ids.some((id) => id.includes('body'))).toBe(true)
})
it('every place reads the same parsed document per text', async () => {
await mount()
const seen: unknown[] = []
function Probe() {
seen.push(useSheetDocument())
return null
}
const first = render(
<>
<Probe />
<Probe />
</>,
)
expect(seen[0]).not.toBeNull()
expect(seen[1]).toBe(seen[0])
first.unmount()
act(() => {
store.getState().commit({
op: 'insert',
element: {
kind: 'category',
value: { id: 'cat-z', name: name('Z'), color: null },
},
})
})
seen.length = 0
render(
<>
<Probe />
<Probe />
</>,
)
expect(seen[1]).toBe(seen[0])
expect(seen[0]).toMatchObject({
categories: expect.arrayContaining([
expect.objectContaining({ id: 'cat-z' }),
]),
})
})
})
describe('a request reaches only its owner', () => {
it('a finding request focuses the findings place while others are mounted', async () => {
await mount(findingsText())
await userEvent.setup().click(tab('Constats'))
await userEvent.setup().click(tab('Général'))
const consumed = vi.fn()
const { unmount } = render(
<FocusConsumedContext value={consumed}>
<EditorTabBody
tab="findings"
visited={['general', 'annotations', 'findings']}
readOnly={false}
navigate={vi.fn()}
reloadSheet={vi.fn()}
focus={{
target: targetOfKey({
kind: 'finding',
zone_id: 'zone-a',
path: ['fcat-a'],
}),
serial: 9,
}}
annotations={{
section: 'drawing',
visited: ['drawing'],
onOpenSection: vi.fn(),
onBack: vi.fn(),
}}
/>
</FocusConsumedContext>,
)
await waitFor(() => expect(consumed).toHaveBeenCalledTimes(1))
expect(consumed).toHaveBeenCalledWith(9, 'found')
unmount()
})
it('after « Aller à » a finding, arrowing back onto Constats keeps the focus on the tab', async () => {
const text = insert(findingsText(), {
...point('anno-bare', 10, 10, 2),
})
const user = await mount(text)
await user.click(tab('Constats'))
await user.click(
inPlace('findings').getByRole('treeitem', { name: /Cat A/ }),
)
await user.click(tab('Annotations'))
tab('Annotations').focus()
await user.keyboard('{ArrowRight}')
expect(tab('Constats')).toHaveAttribute('aria-selected', 'true')
expect(document.activeElement).toBe(tab('Constats'))
})
})
describe('« Aller à » while a creation or a tracing is in progress', () => {
const liveText = () =>
document.querySelector('p[aria-live="polite"]')?.textContent ?? ''
function bareAnnotationText(): string {
const bare = point('anno-bare', 10, 10, 2)
const value = { ...bare.value, geometry: null, name: name('Sans tracé') }
return insert(drawnText(), { kind: 'annotation', value } as typeof bare)
}
async function gotoBare(
user: ReturnType<typeof userEvent.setup>,
start: () => Promise<void>,
) {
await waitFor(() =>
expect(
inPlace('annotations.drawing').getByRole('button', { name: 'Zone' }),
).toBeEnabled(),
)
await start()
await user.click(tab(/Vérification/))
await user.click(
inPlace('verification').getAllByRole('button', {
name: 'Aller à Sans tracé',
})[0],
)
}
it('a tracing from the Zone tool is kept and focused', async () => {
const user = await mount(bareAnnotationText())
await gotoBare(user, async () => {
await user.click(
inPlace('annotations.drawing').getByRole('button', { name: 'Zone' }),
)
fireEvent.click(screen.getByTestId('annotation-canvas'), {
clientX: 20,
clientY: 20,
})
})
expect(tab('Annotations')).toHaveAttribute('aria-selected', 'true')
const bar = within(place('annotations.drawing')).getByTestId('tracing-bar')
expect(bar).toBeVisible()
await waitFor(() => expect(document.activeElement).toBe(bar))
expect(liveText()).toContain('tracé est en cours')
})
it('a « Remplacer par un polygone » tracing is kept and focused (it cannot coexist with a pending creation)', async () => {
const zone = point('zone-a', 0, 0, 1)
const zoneValue = {
...zone.value,
kind: 'zone',
geometry: { type: 'path', d: 'M 20 20 L 80 20 L 50 80 Z' },
}
const text = insert(bareAnnotationText(), {
kind: 'annotation',
value: zoneValue,
} as typeof zone)
const user = await mount(text)
await gotoBare(user, async () => {
const drawing = inPlace('annotations.drawing')
const list = drawing.getByRole('list', { name: 'Annotations de la vue' })
await user.click(within(list).getAllByRole('button')[0])
await user.click(
await drawing.findByRole('button', {
name: 'Remplacer par un polygone',
}),
)
expect(drawing.getByTestId('tracing-bar')).toBeVisible()
})
const bar = within(place('annotations.drawing')).getByTestId('tracing-bar')
await waitFor(() => expect(document.activeElement).toBe(bar))
expect(liveText()).toContain('tracé est en cours')
})
it('a pending creation is kept and focused', async () => {
const user = await mount(bareAnnotationText())
await gotoBare(user, async () => {
await user.click(
inPlace('annotations.drawing').getByRole('button', {
name: 'Ajouter un point',
}),
)
})
const panel = within(place('annotations.drawing')).getByTestId(
'annotation-creation',
)
expect(panel).toBeVisible()
await waitFor(() =>
expect(document.activeElement).toHaveAttribute('data-creation-heading'),
)
expect(liveText()).toContain('création est en cours')
})
})