Files
faunosteo/apps/app/e2e/shell/editor-annotations.spec.ts
T
bchanot 9522eb72aa test(tests): probe mode entry and exit for shifts at three widths
Criterion 5: « Déplacer le point », « Déplacer la zone », « Valider la
position », and « Redessiner » entered then cancelled, each under
expectNoShift at 1 024, 1 180 and 1 280 px (seeded point and zone, the
existing multi-width pattern). The editor-touch « Déplacer la zone » entry
joins the probe; its button is centred first, since below xl the sticky top
bar can cover the strip and Playwright would scroll inside the probe.

No assertion removed. No product shift found.
2026-11-18 14:13:53 +01:00

750 lines
30 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,
historyButton,
round2,
shownNumber,
shownPoints,
shownShape,
storedShape,
pressAtBox,
openEditor,
pickAnnotation,
pointOf,
saveDraft,
saveLine,
seedDraft,
selectionTag,
selectTab,
serverDocument,
shapeWith,
standardShape,
UNSAVED_LINE,
openProperties,
} from '../support/editor'
import { expectNoShift, keepNativeFrames } from '../support/layout'
// V1-2.6 A3 (contract C7, C8, C21): points, zones and links by clicks and by keyboard,
// move by drag, edits on the handles (U2 Task 5), undo and redo, then the save.
const dict = fr
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
/** The creation dialog's form (U2 Task 7). */
const creation = (page: Page) => page.getByTestId('annotation-creation')
const creationDialog = (page: Page, kind: string) =>
page.getByRole('dialog', { name: dict[`editor.annotations.new.${kind}`] })
/** The selection's commands in the strip (U2 Task 6: the properties are a dialog). */
const properties = (page: Page) =>
page.locator('[data-testid="edit-strip"]:has([data-properties-button])')
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 dialog; the category keeps its first choice (A4). */
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)
// A7: back to « Sélectionner », the new element selected.
await expect(tool(page, 'select')).toHaveAttribute('aria-pressed', 'true')
}
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; handle edit; undo and redo; save', async ({
page,
requests,
}) => {
const { actor, seed } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
const line = page.getByTestId('gesture-line')
// An entry of the editor's own below this one, for the Back further down.
await selectTab(page, dict, 'general')
await selectTab(page, dict, 'annotations')
// A point: the tool, a click in the drawing, the dialog « Nouveau point » (A2).
await tool(page, 'point').click()
await clickDrawing(page, 300, 300)
await expect(creationDialog(page, 'point')).toBeVisible()
await expect(page.getByTestId('overlay-ghost')).toBeAttached()
await expect(page.getByTestId('annotation-canvas')).toHaveAttribute(
'data-creating',
'',
)
await expectAccessible(page, 'the point creation dialog')
// A Back while the dialog is open: refused (a modal, no history layer), the question
// inside the dialog (A12); the tab stays.
await page.goBack()
const ask = creationDialog(page, 'point').getByRole('group', {
name: dict['editor.annotations.guard.creation'],
})
await expect(ask).toBeVisible()
await expect(page.locator('dialog[open]')).toHaveCount(1)
await ask
.getByRole('button', { name: dict['editor.annotations.guard.continue'] })
.click()
await expect(ask).toHaveCount(0)
await expect(creationDialog(page, 'point')).toBeVisible()
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()
await expect(line).toContainText(
dict['editor.annotations.message.created.point'],
)
const placed = await shownNumber(page, 'cx')
expect(Math.abs(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 expectAccessible(page, 'a zone tracing in progress')
await page
.getByRole('button', { name: dict['editor.annotations.trace_close'] })
.click()
await expect(creationDialog(page, 'zone')).toBeVisible()
await expectAccessible(page, 'the zone creation dialog')
await fillCreation(page, { fr: 'Zone une', en: 'Zone one' })
await createFromPanel(page)
await expect(selectionTag(page)).toContainText('Zone une')
await expect(line).toContainText(
dict['editor.annotations.message.created.zone'],
)
// 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()
// Each creation is one step: « Défaire » removes the link, « Refaire » brings it back.
const rows = list(page).getByRole('button')
await expect(rows.filter({ hasText: 'Accès un' })).toHaveCount(1)
await historyButton(page, dict, 'undo').click()
await expect(rows.filter({ hasText: 'Accès un' })).toHaveCount(0)
await expect(rows.filter({ hasText: 'Zone une' })).toHaveCount(1)
await historyButton(page, dict, 'redo').click()
await expect(rows.filter({ hasText: 'Accès un' })).toHaveCount(1)
// A keyboard edit on the point's handle (two steps of 5 units), then undo and redo.
await tool(page, 'select').click()
await pickAnnotation(page, dict, /Point un/)
await page
.getByRole('button', { name: 'Point Point un', exact: true })
.focus()
await page.keyboard.press('ArrowRight')
await page.keyboard.press('ArrowRight')
await page.keyboard.press('Enter')
const moved = String(round2(round2(placed + 5) + 5))
await expect(shownShape(page)).toHaveAttribute('cx', moved)
await historyButton(page, dict, 'undo').click()
await expect(shownShape(page)).toHaveAttribute('cx', String(placed))
await historyButton(page, dict, 'redo').click()
await expect(shownShape(page)).toHaveAttribute('cx', moved)
// Nothing left to redo: the button is aria-disabled and a press changes nothing.
await pressAtBox(page, historyButton(page, dict, 'redo'))
await expect(shownShape(page)).toHaveAttribute('cx', moved)
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 x0 = String(await shownNumber(page, 'cx'))
const y0 = String(await shownNumber(page, 'cy'))
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(shownShape(page)).toHaveAttribute('cx', x0)
await expect(shownShape(page)).toHaveAttribute('cy', y0)
// A1: a click on the selected point opens its properties (U2 Task 6); closed again.
await expect(page.getByRole('dialog')).toBeVisible()
await page.keyboard.press('Escape')
await expect(page.getByRole('dialog')).toHaveCount(0)
// 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(shownShape(page)).not.toHaveAttribute('cx', x0)
expect(Math.abs((await shownNumber(page, 'cx')) - 400)).toBeLessThan(2)
expect(Math.abs((await shownNumber(page, 'cy')) - 360)).toBeLessThan(2)
await page.keyboard.press('Control+z')
await expect(shownShape(page)).toHaveAttribute('cx', x0)
})
// UX_TESTS « Keyboard »: create a zone, add and remove a vertex, move the zone, validate.
test('keyboard only: a zone by « Ajouter une zone », a vertex added and removed, moved, validated', async ({
page,
requests,
}) => {
const { actor, seed } = await openAnnotations(page)
requests.forbid(actor.account.email, actor.account.password)
await page
.getByRole('button', { name: dict['editor.annotations.add.zone'] })
.focus()
await page.keyboard.press('Enter')
await expect(creationDialog(page, 'zone')).toBeVisible()
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(creation(page)).toHaveCount(0)
await expect(selectionTag(page)).toContainText('Zone clavier')
// Board 32: « Créer » réussi, the focus on the new row.
await expect(
list(page).getByRole('button', { name: /Zone clavier/ }),
).toBeFocused()
const [first] = await shownPoints(page)
expect(await shownPoints(page)).toHaveLength(3)
// « + » after vertex 1 by Enter: four vertices; Delete on the chosen one: three again.
await page
.getByRole('button', {
name: 'Ajouter un sommet après le sommet 1 de Zone clavier',
})
.focus()
await page.keyboard.press('Enter')
await expect.poll(async () => (await shownPoints(page)).length).toBe(4)
await page
.getByRole('button', { name: 'Sommet 2 de Zone clavier', exact: true })
.focus()
await page.keyboard.press('Delete')
await expect.poll(async () => (await shownPoints(page)).length).toBe(3)
// Escape unchooses the vertex (board 32 row 5): the strip offers the zone's move.
await page.keyboard.press('Escape')
// The move mode by its keys: two steps right, then « Valider la position ».
await page
.getByRole('button', { name: dict['editor.annotations.move.zone'] })
.focus()
await page.keyboard.press('Enter')
const right = page.getByRole('button', {
name: dict['editor.annotations.move.right'],
})
await right.focus()
await page.keyboard.press('Enter')
await page.keyboard.press('Enter')
await page
.getByRole('button', { name: dict['editor.annotations.move.confirm'] })
.focus()
await page.keyboard.press('Enter')
await expect
.poll(async () => (await shownPoints(page))[0][0])
.toBe(round2(round2(first[0] + 5) + 5))
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)
const sheet = await openProperties(page, dict)
await sheet
.getByRole('button', { name: dict['editor.annotations.mark_reviewed'] })
.click()
await expect(
sheet.getByRole('button', {
name: dict['editor.annotations.to_confirm'],
}),
).toBeVisible()
await sheet
.getByRole('button', { name: dict['editor.action.delete'] })
.click()
await page
.locator('dialog[open]')
.last()
.getByRole('button', { name: dict['editor.delete.confirm'] })
.click()
await expect(page.locator('dialog[open]')).toHaveCount(0)
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')
})
test.describe('the drawing never moves (A14)', () => {
const button = (page: Page, key: string) =>
page.getByRole('button', { name: dict[key], exact: true })
const line = (page: Page) => page.getByTestId('gesture-line')
async function openWithPoint(
page: Page,
width: number,
...others: unknown[]
) {
await page.setViewportSize({ width, height: 800 })
// Installed before any timer: the message's 6 s run on this clock (fast-forwarded below).
await keepNativeFrames(page)
await page.clock.install()
const actor = await editorActor('fr')
const point = pointOf('p-a', 'main', { cx: 500, cy: 300, r: 40 }, 'Pt A')
const seed = await seedDraft(actor, {
shape: shapeWith(point, ...others),
})
await openEditor(page, dict, actor, seed.sheetId)
await expect(tool(page, 'point')).toBeEnabled()
return actor
}
/** A drag of the point from (500, 300) to `to`, in drawing units. */
async function dragPoint(page: Page, to: { x: number; y: number }) {
const from = await clientOf(page, 500, 300)
const end = await clientOf(page, to.x, to.y)
await page.mouse.move(from.x, from.y)
await page.mouse.down()
await page.mouse.move(end.x, end.y, { steps: 6 })
await page.mouse.up()
}
for (const width of [1024, 1180, 1280]) {
test(`at ${width} px: selection, tools, tracing, the first commit, the message`, async ({
page,
requests,
}) => {
const actor = await openWithPoint(page, width)
requests.forbid(actor.account.email, actor.account.password)
await expectNoShift(page, async () => {
await clickDrawing(page, 500, 300)
await expect(selectionTag(page)).toContainText('Pt A')
})
// The first commit: the save line changes, the message shows.
await expectNoShift(page, async () => {
await dragPoint(page, { x: 560, y: 330 })
await expect(line(page)).toContainText(
dict['editor.annotations.message.moved.point'],
)
await expect(saveLine(page)).toHaveText(UNSAVED_LINE)
})
// Its own row, the column's width: the message is read whole.
const cut = await line(page)
.locator('span')
.first()
.evaluate((span) => span.scrollWidth > span.clientWidth)
expect(cut, 'the message is cut short').toBe(false)
// M-5: « Défaire » answers 44 px tall below xl (36 px from xl), the pill unchanged.
// In view first: a point outside the viewport hits nothing. The scroll is put back
// after « Défaire » below, so the steps after it press their buttons in place.
const scrolled = await page.evaluate(() => window.scrollY)
const undoOnLine = line(page).getByRole('button', {
name: dict['editor.history.undo_title'],
})
await undoOnLine.evaluate((button) =>
button.scrollIntoView({ block: 'center' }),
)
const reach = width < 1280 ? 44 : 36
// Hit-tested 1 px inside each edge, and the hit box measured whole.
const hit = await undoOnLine.evaluate((button, tall) => {
const box = button.getBoundingClientRect()
const x = box.left + box.width / 2
const mid = box.top + box.height / 2
const at = (dy: number) => document.elementFromPoint(x, mid + dy)
const pill = button.closest('[data-testid="gesture-message"]')!
const area = getComputedStyle(button, '::before').height
return {
top: at(1 - tall / 2) === button,
bottom: at(tall / 2 - 1) === button,
tall: parseFloat(area) >= tall,
pill: pill.getBoundingClientRect().height,
}
}, reach)
expect(hit, `a ${reach} px hit area at ${width} px`).toEqual({
top: true,
bottom: true,
tall: true,
pill: 36,
})
// M-4: the line's « Défaire »: the drawing takes the focus, nothing moves or scrolls.
await expectNoShift(page, async () => {
await undoOnLine.click()
await expect(line(page)).not.toContainText(
dict['editor.annotations.message.moved.point'],
)
})
await expect(
page.locator(
'[data-place="annotations.drawing"] [role="group"][tabindex="0"]',
),
).toBeFocused()
// Moved again: the message whose expiry is checked next.
await expectNoShift(page, async () => {
await dragPoint(page, { x: 560, y: 330 })
await expect(line(page)).toContainText(
dict['editor.annotations.message.moved.point'],
)
})
await page.evaluate((y) => window.scrollTo(0, y), scrolled)
// Its expiry, 6 s later.
await expectNoShift(page, async () => {
await page.clock.fastForward(6_100)
await expect(line(page)).not.toContainText(
dict['editor.annotations.message.moved.point'],
)
})
await expectNoShift(page, async () => {
await clickDrawing(page, 20, 20)
await expect(selectionTag(page)).toHaveCount(0)
})
await expectNoShift(page, () => tool(page, 'zone').click())
await expectNoShift(page, () => clickDrawing(page, 600, 150))
for (const [x, y] of [
[800, 150],
[700, 400],
])
await expectNoShift(page, () => clickDrawing(page, x, y))
await expectNoShift(page, () =>
button(page, 'editor.annotations.trace_pop').click(),
)
await expectNoShift(page, () => clickDrawing(page, 700, 400))
// The close opens « Nouvelle zone » over the column: nothing under it moves.
await expectNoShift(page, async () => {
await button(page, 'editor.annotations.trace_close').click()
await expect(creationDialog(page, 'zone')).toBeVisible()
})
// « Reprendre le tracé » (board 04 C): the dialog hides, the strip offers its way
// back; nothing moves, the commands fit, then « Revenir aux propriétés ».
await expectNoShift(page, async () => {
await creationDialog(page, 'zone')
.getByRole('button', {
name: dict['editor.annotations.creation.resume'],
})
.click()
await expect(creationDialog(page, 'zone')).toHaveCount(0)
})
const strip = page.getByTestId('edit-strip')
await expect(strip).toContainText(
dict['editor.annotations.strip.resumed'],
)
const fence = (await strip.boundingBox())!
const last = (await strip
.getByRole('button', {
name: dict['editor.annotations.creation.discard'],
})
.boundingBox())!
expect(last.x + last.width).toBeLessThanOrEqual(fence.x + fence.width)
await expectAccessible(page, `a resumed tracing at ${width} px`)
await expectNoShift(page, async () => {
await button(page, 'editor.annotations.back_to_properties').click()
await expect(creationDialog(page, 'zone')).toBeVisible()
})
// The zone abandoned (asked inside its dialog), then a point placed and replaced:
// « Taille » shows beside « Revenir aux propriétés » (board 02), nothing moves.
await creationDialog(page, 'zone')
.getByRole('button', {
name: dict['editor.annotations.creation.discard'],
})
.click()
await creationDialog(page, 'zone')
.getByRole('group', {
name: dict['editor.annotations.guard.creation'],
})
.getByRole('button', {
name: dict['editor.annotations.guard.discard'],
})
.click()
await expect(creationDialog(page, 'zone')).toHaveCount(0)
await tool(page, 'point').click()
await clickDrawing(page, 300, 500)
await expect(creationDialog(page, 'point')).toBeVisible()
await expect(strip.getByTestId('size-slider')).toHaveCount(0)
await expectNoShift(page, async () => {
await creationDialog(page, 'point')
.getByRole('button', {
name: dict['editor.annotations.creation.replace'],
})
.click()
await expect(creationDialog(page, 'point')).toHaveCount(0)
await expect(strip.getByTestId('size-slider')).toBeVisible()
})
const edge = (await strip.boundingBox())!
const end = (await strip
.getByRole('button', {
name: dict['editor.annotations.creation.discard'],
})
.boundingBox())!
expect(end.x + end.width).toBeLessThanOrEqual(edge.x + edge.width)
await expectNoShift(page, async () => {
await clickDrawing(page, 320, 520)
await expect(creationDialog(page, 'point')).toBeVisible()
})
})
}
const zoneA = {
...pointOf('z-a', 'main', { cx: 0, cy: 0, r: 1 }, 'Zone A'),
kind: 'zone',
geometry: {
type: 'polygon',
points: [
[650, 150],
[850, 150],
[850, 350],
[650, 350],
],
},
}
/** A « Déplacer … » mode entered, one step, left by « Valider la position »: nothing moves. */
async function moveRoundTrip(page: Page, entry: string) {
const right = button(page, 'editor.annotations.move.right')
await expectNoShift(page, async () => {
await button(page, entry).click()
await expect(right).toBeVisible()
})
await expectNoShift(page, () => right.click())
await expectNoShift(page, async () => {
await button(page, 'editor.annotations.move.confirm').click()
await expect(right).toHaveCount(0)
})
await expect(button(page, entry)).toBeFocused()
}
for (const width of [1024, 1180, 1280]) {
test(`at ${width} px: the move modes and « Redessiner », entered and left`, async ({
page,
requests,
}) => {
const actor = await openWithPoint(page, width, zoneA)
requests.forbid(actor.account.email, actor.account.password)
await clickDrawing(page, 500, 300)
await expect(selectionTag(page)).toContainText('Pt A')
await moveRoundTrip(page, 'editor.annotations.move.point')
await clickDrawing(page, 750, 250)
await expect(selectionTag(page)).toContainText('Zone A')
await moveRoundTrip(page, 'editor.annotations.move.zone')
const redraw = button(page, 'editor.annotations.redraw')
const cancel = button(page, 'editor.annotations.trace_cancel')
await expectNoShift(page, async () => {
await redraw.click()
await expect(cancel).toBeVisible()
})
await expectNoShift(page, async () => {
await cancel.click()
await expect(cancel).toHaveCount(0)
})
await expect(redraw).toBeFocused()
})
}
test('the point (U2 Task 4): handle drag, size by a track click, the move mode', async ({
page,
requests,
}) => {
const actor = await openWithPoint(page, 1280)
requests.forbid(actor.account.email, actor.account.password)
await expectNoShift(page, async () => {
await clickDrawing(page, 500, 300)
await expect(selectionTag(page)).toContainText('Pt A')
})
const handle = page.getByRole('button', {
name: 'Point Pt A',
exact: true,
})
await expect(handle).toHaveAttribute('tabindex', '0')
const slider = page.getByTestId('size-slider').getByRole('slider')
await expect(slider).toHaveValue('40')
await expectAccessible(page, 'a selected point: handle, slider, move')
// The handle follows the pointer; the drop is one commit.
await expectNoShift(page, async () => {
await dragPoint(page, { x: 560, y: 330 })
await expect(line(page)).toContainText(
dict['editor.annotations.message.moved.point'],
)
})
expect(Math.abs((await shownNumber(page, 'cx')) - 560)).toBeLessThan(2)
// A click on the track, no drag (WCAG 2.5.7): one commit at the release.
const track = (await slider.boundingBox())!
await expectNoShift(page, async () => {
await page.mouse.click(
track.x + track.width * 0.8,
track.y + track.height / 2,
)
await expect(line(page)).toContainText(
dict['editor.annotations.message.resized'],
)
})
expect(await shownNumber(page, 'r')).toBeGreaterThan(40)
await page.keyboard.press('Control+z')
await expect(shownShape(page)).toHaveAttribute('r', '40')
// The move mode: three steps (5 units each on a 1 000 px wide frame), validated once.
const x0 = await shownNumber(page, 'cx')
await expectNoShift(page, () =>
button(page, 'editor.annotations.move.point').click(),
)
const right = button(page, 'editor.annotations.move.right')
await expect(right).toBeVisible()
await expectAccessible(page, 'the move mode')
await expectNoShift(page, async () => {
for (let step = 0; step < 3; step++) await right.click()
})
// Nothing committed yet: the stored place stays, drawn as the old place.
await expect(storedShape(page)).toHaveAttribute('cx', String(x0))
await expectNoShift(page, async () => {
await button(page, 'editor.annotations.move.confirm').click()
await expect(right).toHaveCount(0)
})
await expect(shownShape(page)).toHaveAttribute('cx', String(x0 + 15))
await expect(storedShape(page)).toHaveCount(0)
await expect(button(page, 'editor.annotations.move.point')).toBeFocused()
})
test('the point handle keeps its size in CSS px under zoom (R-9)', async ({
page,
requests,
}) => {
await page.setViewportSize({ width: 1280, height: 800 })
const actor = await editorActor('fr')
const tiny = pointOf('p-t', 'main', { cx: 500, cy: 300, r: 4 }, 'Pt T')
const seed = await seedDraft(actor, { shape: shapeWith(tiny) })
await openEditor(page, dict, actor, seed.sheetId)
requests.forbid(actor.account.email, actor.account.password)
await pickAnnotation(page, dict, /Pt T/)
const hit = page.getByTestId('point-handle').locator('[data-handle]')
const fit = (await hit.boundingBox())!
// R-9: a 10 px hit radius with a mouse (Chromium desktop has a fine pointer).
expect(Math.abs(fit.width - 20)).toBeLessThan(2)
// The drawing's own scale: the measure below waits for the zoom to land.
const transform = () =>
page
.getByTestId('annotation-canvas')
.evaluate(
(box) => (box.firstElementChild as HTMLElement).style.transform,
)
const before = await transform()
await page
.getByRole('button', { name: dict['catalogue.zoom.in'] })
.click()
await expect.poll(transform).not.toBe(before)
const zoomed = (await hit.boundingBox())!
expect(Math.abs(zoomed.width - 20)).toBeLessThan(2)
})
test('the editor keeps a stable scrollbar gutter; the dashboard does not', async ({
page,
requests,
}, info) => {
test.skip(
info.project.name !== 'chromium-desktop',
'measured at 1 280 px',
)
const actor = await openWithPoint(page, 1280)
requests.forbid(actor.account.email, actor.account.password)
const gutter = () =>
page.evaluate(
() => getComputedStyle(document.documentElement).scrollbarGutter,
)
expect(await gutter()).toBe('stable')
await page.goto('/app')
await expect(page.locator('[data-editor-workspace]')).toHaveCount(0)
expect(await gutter()).toBe('auto')
})
})
})