Files
faunosteo/apps/app/e2e/shell/editor-annotations.spec.ts
T
bchanot 99b669bf8f feat(editor): header history, save line and Abandonner les modifications
Header Annuler/Retablir on every tab (aria-disabled, commit on pointerdown,
refused blur commit skips the undo). Save line: unsaved count selector
(savedDistance), saveLineState forms, server save time via readSaveTime
(lastSave in the store, never the browser clock). Discard relabelled and
names the stored copy. Tool column pair removed, glyphs in EditorGlyph.

Rewritten or removed assertions (R-24):
- editor-route.test: Revision 3 / unsaved text / Annuler les modifications
  -> save-line testid, Abandonner label, copy sentence in the dialog
- editor-route-conflict, editor-route-recovery: Revision n and copy_cap/
  copy_quota text queries -> save-line testid
- editor-no-loss: discard button label
- editor-annotations-tab: tool column undo/redo test -> no pair left
  (behaviour moved to editor-history-buttons.test)
- e2e journey/annotations/recovery/structures/support saveDraft/lan:
  undo/redo and revision/unsaved text -> historyButton, saveLine helpers;
  structures toHaveCount(0) on old text -> exact Revision n line
- editor-shell clickability: header Annuler/Retablir added
2026-11-08 17:55:49 +01:00

290 lines
10 KiB
TypeScript

import { fr } from '@/i18n/fr'
import type { Page, TestInfo } from '@playwright/test'
import { expect, expectAccessible, test } from '../support/browser'
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
import {
clickDrawing,
clientOf,
editorActor,
geometryField,
historyButton,
pressAtBox,
openEditor,
pickAnnotation,
saveDraft,
seedDraft,
selectionTag,
selectTab,
serverDocument,
standardShape,
} from '../support/editor'
// V1-2.6 A3 (contract C7, C8, C21): points, zones and links by clicks and by keyboard,
// move by drag, numeric edits, undo and redo, then the save that carries them.
const dict = fr
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
const creation = (page: Page) => page.getByTestId('annotation-creation')
const properties = (page: Page) => page.getByTestId('annotation-properties')
const list = (page: Page) =>
page.getByRole('list', { name: dict['editor.annotations.list'] })
const tool = (page: Page, id: string) =>
page.getByRole('button', {
name: dict[`editor.annotations.tool.${id}`],
exact: true,
})
interface Names {
fr: string
en: string
}
/** Fills the creation panel; the category keeps its first choice. */
async function fillCreation(page: Page, names: Names, opens?: string) {
const panel = creation(page)
await panel.getByLabel(dict['editor.annotations.name_fr']).fill(names.fr)
await panel.getByLabel(dict['editor.annotations.name_en']).fill(names.en)
await panel
.getByLabel(dict['editor.annotations.laterality'])
.selectOption('unpaired')
if (opens) {
await panel.getByLabel(dict['editor.annotations.opens']).selectOption(opens)
}
}
async function createFromPanel(page: Page) {
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.click()
await expect(creation(page)).toHaveCount(0)
}
async function openAnnotations(page: Page) {
const actor = await editorActor('fr')
const seed = await seedDraft(actor, { shape: standardShape })
await openEditor(page, dict, actor, seed.sheetId)
await expect(tool(page, 'point')).toBeEnabled()
return { actor, seed }
}
test.describe('editor annotations (A3)', () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('point, zone and link by clicks; numeric edit; undo and redo; save', async ({
page,
requests,
}) => {
const { actor, seed } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
// A point: the tool, a click in the drawing, the fields the core requires.
await tool(page, 'point').click()
await clickDrawing(page, 300, 300)
await expect(creation(page)).toBeVisible()
await expectAccessible(page, 'the point creation panel')
await fillCreation(page, { fr: 'Point un', en: 'Point one' })
await creation(page)
.getByLabel(dict['editor.annotations.zone'])
.selectOption('zone-a')
await createFromPanel(page)
await expect(selectionTag(page)).toContainText('Point un')
await expect(properties(page)).toBeVisible()
const placed = await geometryField(page, dict, 'cx').inputValue()
expect(Math.abs(Number(placed) - 300)).toBeLessThan(1)
// A zone: three clicks, then « Fermer le tracé ».
await tool(page, 'zone').click()
for (const [x, y] of [
[600, 200],
[800, 200],
[700, 400],
])
await clickDrawing(page, x, y)
await page
.getByRole('button', { name: dict['editor.annotations.trace_close'] })
.click()
await fillCreation(page, { fr: 'Zone une', en: 'Zone one' })
await createFromPanel(page)
await expect(selectionTag(page)).toContainText('Zone une')
// A link to the detail view: the same tracing, the opened view chosen.
await tool(page, 'link').click()
for (const [x, y] of [
[150, 500],
[350, 500],
[250, 700],
])
await clickDrawing(page, x, y)
await page
.getByRole('button', { name: dict['editor.annotations.trace_close'] })
.click()
await fillCreation(page, { fr: 'Accès un', en: 'Access one' }, 'detail-a')
await createFromPanel(page)
await expect(selectionTag(page)).toContainText('Accès un')
await expect(historyButton(page, dict, 'undo')).toBeEnabled()
// A numeric edit of the point, then undo and redo.
await pickAnnotation(page, dict, /Point un/)
const cx = geometryField(page, dict, 'cx')
await cx.fill('420')
await cx.press('Enter')
await expect(cx).toHaveValue('420')
await historyButton(page, dict, 'undo').click()
await expect(geometryField(page, dict, 'cx')).toHaveValue(placed)
await historyButton(page, dict, 'redo').click()
await expect(geometryField(page, dict, 'cx')).toHaveValue('420')
// Nothing left to redo: the button is aria-disabled and a press changes nothing.
await pressAtBox(page, historyButton(page, dict, 'redo'))
await expect(geometryField(page, dict, 'cx')).toHaveValue('420')
await saveDraft(page, dict, seed.revision + 1)
const saved = await serverDocument<{
annotations: { kind: string; finding_zone_id?: string | null }[]
}>(seed.draftId)
expect(saved.annotations.map((a) => a.kind).sort()).toEqual([
'detail_trigger',
'point',
'zone',
])
expect(
saved.annotations.find((a) => a.kind === 'point')?.finding_zone_id,
).toBe('zone-a')
})
test('a click with jitter never moves; a drag moves by the pointer delta', async ({
page,
requests,
}) => {
const { actor } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
await tool(page, 'point').click()
await clickDrawing(page, 300, 300)
await fillCreation(page, { fr: 'Mobile', en: 'Movable' })
await createFromPanel(page)
await tool(page, 'select').click()
const cx = geometryField(page, dict, 'cx')
const cy = geometryField(page, dict, 'cy')
const [x0, y0] = [await cx.inputValue(), await cy.inputValue()]
expect(Math.abs(Number(x0) - 300)).toBeLessThan(1)
// Jitter under the 4 px threshold: pressed, moved by 3 px, released.
const from = await clientOf(page, 300, 300)
await page.mouse.move(from.x, from.y)
await page.mouse.down()
await page.mouse.move(from.x + 2, from.y + 2)
await page.mouse.up()
await expect(cx).toHaveValue(x0)
await expect(cy).toHaveValue(y0)
// A real drag: the point follows to (400, 360) in drawing units.
const to = await clientOf(page, 400, 360)
await page.mouse.move(from.x, from.y)
await page.mouse.down()
await page.mouse.move((from.x + to.x) / 2, (from.y + to.y) / 2, {
steps: 5,
})
await page.mouse.move(to.x, to.y, { steps: 5 })
await page.mouse.up()
await expect(cx).not.toHaveValue(x0)
expect(Math.abs(Number(await cx.inputValue()) - 400)).toBeLessThan(2)
expect(Math.abs(Number(await cy.inputValue()) - 360)).toBeLessThan(2)
await page.keyboard.press('Control+z')
await expect(geometryField(page, dict, 'cx')).toHaveValue(x0)
})
test('keyboard only: creation by the add buttons, numeric position, numeric edit', async ({
page,
requests,
}) => {
const { actor, seed } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
const add = page.getByRole('button', {
name: dict['editor.annotations.add.point'],
})
await add.focus()
await page.keyboard.press('Enter')
await expect(creation(page)).toBeVisible()
await fillCreation(page, { fr: 'Clavier', en: 'Keyboard' })
const cx = creation(page).getByLabel(dict['editor.annotations.geometry.cx'])
await cx.fill('250')
await cx.press('Enter')
await expect(cx).toHaveValue('250')
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.focus()
await page.keyboard.press('Enter')
await expect(creation(page)).toHaveCount(0)
await expect(selectionTag(page)).toContainText('Clavier')
await expect(geometryField(page, dict, 'cx')).toHaveValue('250')
const cy = geometryField(page, dict, 'cy')
await cy.fill('510.5')
await cy.press('Enter')
await expect(cy).toHaveValue('510.5')
// A polygon edit: the zone added by keyboard, a vertex typed.
await page
.getByRole('button', { name: dict['editor.annotations.add.zone'] })
.focus()
await page.keyboard.press('Enter')
await fillCreation(page, { fr: 'Zone clavier', en: 'Keyboard zone' })
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.focus()
await page.keyboard.press('Enter')
await expect(selectionTag(page)).toContainText('Zone clavier')
const vertexX = page.getByLabel(
dict['editor.annotations.geometry.vertex_x'].replace('{n}', '1'),
)
const before = Number(await vertexX.inputValue())
await vertexX.fill(String(before + 10))
await vertexX.press('Enter')
await expect(vertexX).toHaveValue(String(before + 10))
await saveDraft(page, dict, seed.revision + 1)
})
test('the properties of an annotation: review state and deletion', async ({
page,
requests,
}) => {
const { actor } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
await tool(page, 'point').click()
await clickDrawing(page, 500, 400)
await fillCreation(page, { fr: 'A relire', en: 'To review' })
await createFromPanel(page)
await properties(page)
.getByRole('button', { name: dict['editor.annotations.mark_reviewed'] })
.click()
await expect(
properties(page).getByRole('button', {
name: dict['editor.annotations.to_confirm'],
}),
).toBeVisible()
await properties(page)
.getByRole('button', { name: dict['editor.action.delete'] })
.click()
await page
.getByRole('dialog')
.getByRole('button', { name: dict['editor.delete.confirm'] })
.click()
await expect(list(page)).toHaveCount(0)
await expect(
page.getByText(dict['editor.annotations.list_empty']),
).toBeVisible()
await selectTab(page, dict, 'verification')
await expectAccessible(page, 'the verification tab after a deletion')
})
})