Files
faunosteo/apps/app/e2e/shell/editor-citations.spec.ts
T
bchanot 8db6f4287f feat(editor): contextual citations panel of a finding (board 25)
The panel opens only from a finding's « {n} références » trigger: 34 rem
at most, never wider than the room, a scrim, slide in 180 ms and out
140 ms (motion/react; none under reduced motion, callbacks still fire).
It lists the finding's references as tiles with « Modifier », « Retirer
de ce constat » (one « Défaire » restores it and the review status) and
« Aller à »; dangling ids read « Référence introuvable »; zero left
reads « Ce constat ne cite plus aucune référence. ». « Tout afficher
dans l'onglet Références » resets search and sort, keeps open tiles and
edits. Every close (✕, Escape outside fields, scrim, tab, « Aller à »,
« Tout afficher », element gone) records one pending move applied
after the exit, page inert until then; focus back to the trigger, else
the active tab button. A refused draft cancels a user close; a forced
close drops it and announces « Saisie non appliquée : {field} ». Places
keeps a permanent dvh min-height; the panel fits the visible viewport
at every scroll position, document size unchanged.

Gates: typecheck, lint, test:run (app 1488), build, e2e:ui 251;
e2e:shell 16 specs on db:sandbox (admin and editor-equine excluded):
117 passed / 107 skipped / 0 failed, rerun after the fix rounds: 118
passed / 108 skipped / 0 failed; layout spec 13 passed after round 2;
full-row guard: no pre-existing row changed in any table. Known limit:
landscape 667 x 375 at scroll 0 leaves ~13 px of panel (the trigger is
below the fold there).

## R-24 (removed or rewritten assertions)

| file | old | new |
|---|---|---|
| editor-references-panel.test.tsx (whole file) | R2.1 interim-panel tests, synchronous closes | rewritten: 39 tests (opening, motion, close matrix in both modes, exit, Retirer, P22'', library + history) |
| same, opening | heading `Références` focused right after the click | heading `Références citées` focused after the enter (`waitFor`), `aria-expanded` only after click |
| same | chip `references-filter-chip` « Citées par « Node A » (2) » | REMOVED (REVUE: path line + count line « 2 références citées par ce constat ») |
| same | `listitem` cards « Citée 2 fois » | tiles (`ul > li`) with the same counts, in the finding's order |
| same | field id `#panel-reference-0-ref-a-citation` present at once | tile opened + « Modifier » first (tiles since R2.2) |
| same | « Tout afficher (3) », sync | « Tout afficher dans l'onglet Références », after exit, heading focus asserted |
| same | Escape / ✕ / scrim / tab / vanish: sync null panel | all `await closed()` + `document.activeElement` checks, `describe.each` normal / reduced motion |
| same | « makes the tab panels inert while open, header usable » | split: inert page + inert panel until the exit ends then lifted; « Défaire / Refaire usable »; the `Enregistrer` enabled check dropped (covered by the focus-moved-off test) |
| same | Ctrl+Z test on an always-open field | open tile + Modifier first |
| same | read-only: no Supprimer, no textbox | open tile: no Modifier, no Retirer, no textbox |
| same | P6 under « Plus »: sync | in the close matrix, awaited |
| editor-escape.test.tsx (2 tests) | `expect(citations()).toBeNull()` right after Escape | `await waitFor(...)`; trigger `aria-expanded` false after exit |
| editor-keep-alive.test.tsx | « Escape in a citations panel field commits the text before the panel closes » | REPLACED by « Escape in a field of a panel tile neither closes nor commits » (A5, P27) |
| same | scrim click closes the panel after committing, sync, id on a closed tile | tile opened in edit first, close awaited, commit asserted before the exit |
| editor-focus-request.test.tsx | `ReferenceLibrary` with `resetSignal`; `ownedBy(ref,'citations')` undefined | `ReferencesTab` (+ `reloadSheet`); the `'citations'` assertion removed with the type |
| editor-references-tab / -view.test.tsx | `ReferenceLibrary`, `resetSignal` | `ReferencesTab`, `libraryReset` (+ `reloadSheet`) |
| e2e support `openCitations` | waited for the panel visible | also waits for the heading focus (slide over) |

New unit coverage: editor-citations-exit.test.tsx (hook, fake timers), editor-findings (aria-expanded per finding),
`useDecisionsOpen` gate, panel file (Retirer + status + one undo, P20 chain, zero state, dangling id, P4 reset, P6 after undo,
P22'' four paths, reduced motion, inert/exit, second close, tab replace, focus-moved-off).

## i18n (FR / EN)

Added: `editor.references.panel_title` Références citées / Cited references; `panel_count_one|other` « {count} référence citée par
ce constat » / « {count} références citées par ce constat » and « {count} reference cited by this finding » / « … references … »;
`panel_show_all` Tout afficher dans l'onglet Références / Show all in the References tab; `panel_empty` Ce constat ne cite plus
aucune référence. / This finding no longer cites any reference.; `remove_citation` Retirer de ce constat / Remove from this finding;
`this_finding` ce constat / this finding; `missing` Référence introuvable / Reference not found; `draft_dropped`
Saisie non appliquée : {field} / Entry not applied: {field}.
Changed: none. Removed: `editor.references.cited_by` (« Citées par « {name} » ({count}) » / « Cited by « {name} » ({count}) »),
`editor.references.show_all` (« Tout afficher ({count}) » / « Show all ({count}) »). R10 grep over src, tests and e2e including
editor-equine: no reader left. `editor-equine` has no panel reference: « updated, not run » (nothing to update). The three
provisional FR labels are exactly as listed in the brief; `…` = the refused field's label.
2026-11-12 22:27:32 +01:00

492 lines
18 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.
import { fr } from '@/i18n/fr'
import type { Locator, Page, TestInfo } from '@playwright/test'
import {
expect,
expectAccessible,
expectNoHorizontalOverflow,
test,
} from '../support/browser'
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
import {
closeCitations,
editorActor,
libraryRoot,
openCitations,
openEditor,
openTab,
place,
saveDraft,
seedDraft,
serverDocument,
standardShape,
} from '../support/editor'
// V1-2.6 R2.4: the contextual citations panel of one finding (board 25): its contents,
// « Retirer de ce constat » and « Défaire », « Tout afficher », every close path with the
// focus checked after the exit (motion and reduced motion), Escape in a tile field, the
// inert page during the exit sampled in the page, axe open (edit, read-only at 375 px).
// The spec seeds its own sheet and never touches another.
const dict = fr
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
/** « Constat A » cites twelve references: its panel list outgrows the screen. */
function longShape(document: Record<string, unknown>) {
shape(document)
const refs = Array.from({ length: 12 }, (_, index) => ({
id: `ref-${index}`,
type: 'book',
citation: `Ouvrage numéro ${index + 1}`,
url: null,
doi: null,
}))
document.references = refs
const zone = (document.finding_zones as { categories: unknown[] }[])[0]
const family = zone.categories[0] as {
reference_ids: string[]
children: { reference_ids: string[] }[]
}
family.reference_ids = []
family.children[0].reference_ids = refs.map((ref) => ref.id)
}
/** « Constat A » cites A, B and C; the family cites B; D is cited by nobody. */
function shape(document: Record<string, unknown>) {
standardShape(document)
const reference = (id: string, citation: string, type = 'book') => ({
id,
type,
citation,
url: null,
doi: null,
})
document.references = [
reference('ref-a', 'Référence A'),
reference('ref-b', 'Source B', 'web'),
reference('ref-c', 'Source C', 'journal'),
reference('ref-d', 'Source libre', 'manual'),
]
const zone = (document.finding_zones as { categories: unknown[] }[])[0]
const family = zone.categories[0] as {
reference_ids: string[]
children: { reference_ids: string[] }[]
}
family.reference_ids = ['ref-b']
family.children[0].reference_ids = ['ref-a', 'ref-b', 'ref-c']
}
async function open(page: Page, seedShape = shape) {
const actor = await editorActor('fr')
const seed = await seedDraft(actor, { shape: seedShape })
await openEditor(page, dict, actor, seed.sheetId)
return { actor, seed }
}
const panel = (page: Page) => page.getByTestId('editor-citations-panel')
const heads = (page: Page) =>
panel(page).locator('button[aria-controls][id$="-header"]')
const trigger = (page: Page) => page.locator('[data-citations-trigger]:visible')
const link = (page: Page) =>
panel(page).getByRole('button', {
name: dict['editor.references.panel_show_all'],
})
const undo = (page: Page) => page.getByRole('button', { name: /Défaire/ })
const retire = (tile: Locator) =>
tile.getByRole('button', { name: dict['editor.references.remove_citation'] })
type Node = { reference_ids: string[]; review_status: string }
const nodeOf = (document: Record<string, unknown>) =>
(
document.finding_zones as {
categories: { children: Node[] }[]
}[]
)[0].categories[0].children[0]
test.describe('citations panel, editing', () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context }, info) => {
test.skip(
isPhone(info),
'editing needs >= 1 024 px; the read-only twin at 375 px is below',
) // floor-guard: allow C16 editing needs >= 1024 px; read-only twin in this file
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('opens filtered on its finding, « Retirer » and one « Défaire », saved status', async ({
page,
requests,
}) => {
test.setTimeout(150_000)
const { actor, seed } = await open(page)
requests.forbid(actor.account.email, actor.account.password)
await openCitations(page, dict, 'Constat A')
await expect(trigger(page)).toHaveAttribute('aria-expanded', 'true')
await expect(panel(page).getByRole('heading')).toHaveText(
dict['editor.references.panel_title'],
)
await expect(panel(page)).toContainText(
'Zone A › Dysfonction A › Constat A',
)
await expect(panel(page)).toContainText(
dict['editor.references.panel_count_other'].replace('{count}', '3'),
)
await expect(heads(page)).toHaveCount(3)
await expect(panel(page).getByText('Source libre')).toHaveCount(0)
await expect(panel(page).getByRole('searchbox')).toHaveCount(0)
await expectAccessible(page, 'the citations panel, closed tiles')
await heads(page).nth(1).click()
const tile = heads(page).nth(1).locator('xpath=ancestor::li[1]')
await expect(
tile.getByText(dict['editor.references.this_finding'], { exact: true }),
).toBeVisible()
await expect(retire(tile)).toBeVisible()
for (const name of [
dict['editor.action.delete'],
dict['editor.action.move_up'],
]) {
await expect(panel(page).getByRole('button', { name })).toHaveCount(0)
}
await expectAccessible(page, 'the citations panel, an open tile')
// « Retirer » then one « Défaire » restores the citation and the status together.
await retire(tile).click()
await expect(heads(page)).toHaveCount(2)
// The next tile (« Source C », now second) takes the focus (P20).
await expect(heads(page).nth(1)).toBeFocused()
await expect(heads(page).nth(1)).toContainText('Source C')
await undo(page).click()
await expect(heads(page)).toHaveCount(3)
// The tile that came back is closed (its open state went with it): open it again.
await heads(page).nth(1).click()
await retire(tile).click()
await expect(heads(page)).toHaveCount(2)
await saveDraft(page, dict, seed.revision + 1)
const saved = await serverDocument<Record<string, unknown>>(seed.draftId)
expect(nodeOf(saved).reference_ids).toEqual(['ref-a', 'ref-c'])
expect(nodeOf(saved).review_status).toBe('to_confirm')
expect((saved.references as unknown[]).length).toBe(4)
})
test('a long list scrolls inside the panel: the last tile is reachable from scroll 0, the page never moves', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page, longShape)
await openCitations(page, dict, 'Constat A')
await expect(heads(page)).toHaveCount(12)
expect(await page.evaluate(() => window.scrollY)).toBe(0)
const list = panel(page).locator('div.overflow-y-auto')
await list.evaluate((node) => {
node.scrollTop = node.scrollHeight
})
const last = heads(page).last()
await expect(last).toBeInViewport({ ratio: 1 })
const view = await page.evaluate(() => window.innerHeight)
const box = await last.boundingBox()
expect(box!.y + box!.height).toBeLessThanOrEqual(view + 1)
expect(await page.evaluate(() => window.scrollY)).toBe(0)
await last.click()
await expect(last).toHaveAttribute('aria-expanded', 'true')
})
test('the last citations gone: the panel stays with its line, then closes on the tab', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
for (const remaining of [2, 1, 0]) {
await heads(page).first().click()
await retire(heads(page).first().locator('xpath=ancestor::li[1]')).click()
await expect(heads(page)).toHaveCount(remaining)
}
await expect(
panel(page).getByText(dict['editor.references.panel_empty']),
).toBeVisible()
await expect(link(page)).toBeVisible()
await expect(page.locator('#editor-citations-title')).toBeFocused()
await page.keyboard.press('Escape')
await expect(panel(page)).toHaveCount(0)
// The trigger went with the last citation: the active tab takes the focus (P6).
await expect(
page.getByRole('tab', { name: dict['editor.tab.findings'] }),
).toBeFocused()
})
test('« Tout afficher » closes it, resets search and sort, keeps open tiles, focuses the tab heading', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openTab(page, dict, 'references')
const root = libraryRoot(page)
await root.getByRole('searchbox').fill('Source')
await root
.getByLabel(dict['editor.references.sort_by'])
.selectOption('citation')
await root.getByRole('button', { name: /Source B/ }).click()
await openCitations(page, dict, 'Constat A')
await link(page).click()
await expect(panel(page)).toHaveCount(0)
await expect(page.locator('#editor-references-title')).toBeFocused()
await expect(root.getByRole('searchbox')).toHaveValue('')
await expect(
root.getByLabel(dict['editor.references.sort_by']),
).toHaveValue('sheet')
await expect(
root.getByRole('button', { name: /Source B/ }),
).toHaveAttribute('aria-expanded', 'true')
await expect(
root.locator('button[aria-controls][id$="-header"]'),
).toHaveCount(4)
})
test('Escape in a field of a tile neither closes the panel nor commits; ✕ then commits', async ({
page,
}) => {
test.setTimeout(150_000)
const { seed } = await open(page)
await openCitations(page, dict, 'Constat A')
await heads(page).first().click()
await panel(page)
.getByRole('button', { name: dict['editor.references.edit'] })
.click()
const field = panel(page).getByLabel(dict['editor.reference.citation'])
await field.fill('Référence A, révisée')
await field.press('Escape')
await expect(panel(page)).toBeVisible()
await expect(field).toHaveValue('Référence A, révisée')
await expect(undo(page)).toBeDisabled()
// A user close applies a valid draft first (P22''), then the panel exits.
await panel(page)
.getByRole('button', { name: dict['editor.references.close'] })
.click()
await expect(panel(page)).toHaveCount(0)
await saveDraft(page, dict, seed.revision + 1)
const saved = await serverDocument<{ references: { citation: string }[] }>(
seed.draftId,
)
expect(saved.references[0].citation).toBe('Référence A, révisée')
})
test('a refused draft cancels the close: panel open, field focused, message shown', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
await heads(page).first().click()
await panel(page)
.getByRole('button', { name: dict['editor.references.edit'] })
.click()
const field = panel(page).getByLabel(dict['editor.reference.citation'])
await field.fill('')
await page
.getByRole('tab', {
name: new RegExp(`^${dict['editor.tab.verification']}`),
})
.click()
await expect(panel(page)).toBeVisible()
await expect(field).toBeFocused()
await expect(panel(page).getByRole('alert')).toBeVisible()
await expect(page.getByRole('tab', { selected: true })).toHaveText(
new RegExp(`^${dict['editor.tab.findings']}`),
)
})
test('the page and the panel are inert through the exit (sampled in the page)', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
await page.evaluate(() => {
const samples: { panel: boolean; page: boolean; inert: boolean }[] = []
Object.assign(window, { samples })
const tick = () => {
const layer = document.querySelector('[data-place="citations"]')
const body = document.querySelector('[data-place="findings"]')
samples.push({
panel: layer !== null,
page: body?.closest('[inert]') !== null,
inert: layer?.hasAttribute('inert') ?? false,
})
if (layer !== null) requestAnimationFrame(tick)
}
tick()
})
await panel(page)
.getByRole('button', { name: dict['editor.references.close'] })
.click()
await expect(panel(page)).toHaveCount(0)
const samples = await page.evaluate(
() =>
(
window as unknown as {
samples: { panel: boolean; page: boolean; inert: boolean }[]
}
).samples,
)
const leaving = samples.filter((sample) => sample.panel && sample.inert)
expect(leaving.length).toBeGreaterThan(0)
expect(leaving.every((sample) => sample.page)).toBe(true)
await expect(page.locator('[data-place="findings"]')).toBeVisible()
expect(
await page
.locator('[data-place="findings"]')
.evaluate((body) => body.closest('[inert]') === null),
).toBe(true)
})
})
/** Every way out of the panel, the focus read from the document after the exit. */
for (const reduced of [false, true]) {
test.describe(`citations panel closes, ${reduced ? 'reduced motion' : 'motion'}`, () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context, page }, info) => {
test.skip(isPhone(info), 'the paths are walked on desktop') // floor-guard: allow C16 editing needs >= 1 024 px
await routeToSandbox(context)
await page.emulateMedia({
reducedMotion: reduced ? 'reduce' : 'no-preference',
})
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('✕, Escape and the scrim give the focus back to the trigger', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
await closeCitations(page, dict)
await expect(trigger(page)).toBeFocused()
await expect(trigger(page)).toHaveAttribute('aria-expanded', 'false')
await trigger(page).click()
await expect(page.locator('#editor-citations-title')).toBeFocused()
await page.keyboard.press('Escape')
await expect(panel(page)).toHaveCount(0)
await expect(trigger(page)).toBeFocused()
await trigger(page).click()
await expect(page.locator('#editor-citations-title')).toBeFocused()
await page
.getByTestId('references-scrim')
.click({ position: { x: 12, y: 40 } })
await expect(panel(page)).toHaveCount(0)
await expect(trigger(page)).toBeFocused()
})
test('« Tout afficher », « Aller à » and a tab choice land where the pending move says', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
await link(page).click()
await expect(panel(page)).toHaveCount(0)
await expect(page.locator('#editor-references-title')).toBeFocused()
await openCitations(page, dict, 'Constat A')
await heads(page).nth(1).click()
await panel(page)
.getByRole('button', { name: dict['editor.references.go_to'] })
.first()
.click()
await expect(panel(page)).toHaveCount(0)
await expect(
page.getByRole('treeitem', { name: /Dysfonction A/ }),
).toBeFocused()
await openCitations(page, dict, 'Constat A')
const verification = page.getByRole('tab', {
name: new RegExp(`^${dict['editor.tab.verification']}`),
})
await verification.click()
await expect(panel(page)).toHaveCount(0)
await expect(verification).toBeFocused()
})
test('the panel slides only when motion is allowed', async ({ page }) => {
test.setTimeout(150_000)
await open(page)
await page.getByRole('tab', { name: dict['editor.tab.findings'] }).click()
await page
.getByRole('treeitem', { expanded: false })
.first()
.press('ArrowRight')
await page.getByRole('treeitem', { name: 'Constat A' }).click()
await page.evaluate(() => {
const seen: string[] = []
Object.assign(window, { seen })
new MutationObserver(() => {
const layer = document.querySelector('[data-place="citations"]')
const slider = layer?.firstElementChild as HTMLElement | null
if (slider) seen.push(slider.style.transform)
}).observe(document.body, {
subtree: true,
childList: true,
attributes: true,
attributeFilter: ['style'],
})
})
await trigger(page).click()
await expect(page.locator('#editor-citations-title')).toBeFocused()
const seen = await page.evaluate(
() => (window as unknown as { seen: string[] }).seen,
)
const slid = seen.some((value) => /translateX\((?!0)[1-9]/.test(value))
expect(slid).toBe(!reduced)
})
})
}
test.describe('citations panel, read-only at 375 px', () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context }, info) => {
test.skip(!isPhone(info), 'the read-only twin runs at 375 px only')
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('full width through « Plus » then Constats, no edit control, axe open @phone', async ({
page,
}) => {
test.setTimeout(150_000)
await open(page)
await openCitations(page, dict, 'Constat A')
// Full width: the whole content area (the page's side gutters stay).
const layer = page.locator('[data-place="citations"]')
const box = await layer.boundingBox()
const area = await layer.locator('xpath=..').boundingBox()
expect(box?.width ?? 0).toBeLessThanOrEqual(375)
expect(Math.abs((box?.width ?? 0) - (area?.width ?? 0))).toBeLessThan(1)
await expect(heads(page)).toHaveCount(3)
await expectNoHorizontalOverflow(page, 'the panel at 375 px')
await heads(page).first().click()
for (const name of [
dict['editor.references.edit'],
dict['editor.references.remove_citation'],
]) {
await expect(panel(page).getByRole('button', { name })).toHaveCount(0)
}
await expect(panel(page).getByRole('textbox')).toHaveCount(0)
const close = await panel(page)
.getByRole('button', { name: dict['editor.references.close'] })
.boundingBox()
expect(close?.width ?? 0).toBeGreaterThanOrEqual(44)
expect(close?.height ?? 0).toBeGreaterThanOrEqual(44)
await expectAccessible(page, 'the citations panel, read-only at 375 px')
await closeCitations(page, dict)
await expect(trigger(page)).toBeFocused()
await expect(place(page, 'findings')).toBeVisible()
})
})