import { fr } from '@/i18n/fr' import type { CDPSession, Locator, Page, TestInfo } from '@playwright/test' import { stepUpAdmin } from '../support/admin' import { expect, expectAccessible, expectNoHorizontalOverflow, test, } from '../support/browser' import { dropLateReplays, routeToSandbox } from '../support/sandbox' import { SECTIONS, TABS, closeCitations, draftPath, draftTitle, editorActor, historyButton, openEditor, openCitations, openTab, openSection, pickAnnotation, place, pointOf, seedDraft, selectTab, shapeWith, showDrawing, } from '../support/editor' import { signIn } from '../support/shell' // V1-2.6 U1 H (AC10, AC11, AC17): the layout of the five-tab shell at every width, the // keyboard order of the editor, and axe on every place, edit and narrow read-only. const dict = fr const isPhone = (info: TestInfo) => info.project.name === 'chromium-375' const WIDTHS = [1024, 1180, 1279, 1280] const NARROW_WIDTHS = [320, 375, 768] const point = pointOf( 'anno-free', 'main', { cx: 120, cy: 120, r: 6 }, 'Point libre', ) async function open(page: Page) { const actor = await editorActor('fr') const seed = await seedDraft(actor, { shape: shapeWith(point) }) await openEditor(page, dict, actor, seed.sheetId) return { ...seed, actor } } /** Selects a finding in the tree of Constats (expanding down to it), the panel closed. */ async function selectFinding(page: Page, name: string) { await openTab(page, dict, 'findings') const item = page.getByRole('treeitem', { name }) for (let depth = 0; depth < 4 && (await item.count()) === 0; depth++) { const closed = page.getByRole('treeitem', { expanded: false }).first() await closed.focus() await closed.press('ArrowRight') } await item.click() } /** * Samples the document's size on every frame until stopped (the click that opens or * closes the panel is inside the window): the distinct sizes seen come back. */ async function watchDocumentSize(page: Page) { await page.evaluate(() => { const seen = new Set() const state = { live: true } const tick = () => { const root = document.documentElement seen.add(`${root.scrollWidth}x${root.scrollHeight}`) if (state.live) requestAnimationFrame(tick) } Object.assign(window, { sizes: seen, sampling: state }) tick() }) return () => page.evaluate(() => { const w = window as unknown as { sizes: Set sampling: { live: boolean } } w.sampling.live = false return [...w.sizes] }) } const REM = 16 /** The panel's own padding (`p-4` top and bottom): its box cannot be shorter than this. */ const PANEL_PADDING_PX = 32 /** * The panel is at most 34 rem and no wider than the viewport, and at scroll 0, halfway and * at the end of the page its bottom is the nearer of the viewport's bottom and its * container's bottom (its visible height is kept right on scroll). */ async function expectPanelWithin( page: Page, viewportWidth: number, cramped = false, ) { const layer = page.locator('[data-place="citations"]') const box = await layer.boundingBox() expect(box!.width).toBeLessThanOrEqual(34 * REM + 0.5) expect(box!.width).toBeLessThanOrEqual(viewportWidth) for (const at of [0, 0.5, 1]) { await page.evaluate((share) => { const root = document.documentElement window.scrollTo(0, (root.scrollHeight - window.innerHeight) * share) }, at) await page.evaluate( () => new Promise((done) => requestAnimationFrame(() => done(null))), ) const edges = await page.evaluate(() => { const container = document.querySelector('[data-place="citations"]')! const panel = document.querySelector('#editor-citations-panel')! const outer = container.getBoundingClientRect() const inner = panel.getBoundingClientRect() const viewport = window.visualViewport?.height ?? window.innerHeight return { panelBottom: inner.bottom, expected: Math.min(viewport, outer.bottom), panelTop: inner.top, } }) if (edges.expected - edges.panelTop < PANEL_PADDING_PX) { // Only the landscape phone at scroll 0 may leave less room than the padding. expect( cramped && at === 0, `panel room below its padding at scroll share ${at}`, ).toBe(true) continue } expect( Math.abs(edges.panelBottom - edges.expected), `panel bottom at scroll share ${at}`, ).toBeLessThanOrEqual(1) expect(edges.panelBottom).toBeGreaterThan(edges.panelTop) } await page.evaluate(() => window.scrollTo(0, 0)) } async function settle(page: Page) { await page.evaluate( () => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)), ), ) } /** Opens the finding by taps only: the caret of a closed row opens the branch. */ async function tapFinding(page: Page, name: string) { await openTab(page, dict, 'findings') const item = page.getByRole('treeitem', { name }) for (let depth = 0; depth < 4 && (await item.count()) === 0; depth++) { const closed = page.getByRole('treeitem', { expanded: false }).first() await closed.locator('span').first().tap() } await item.tap() } /** The window's scrollY once two animation frames in a row agree (no fling left). */ async function stableScrollY(page: Page) { let last = -1 for (let tries = 0; tries < 60; tries++) { await settle(page) const now = await page.evaluate(() => window.scrollY) if (now === last) return now last = now } throw new Error('the scroll never settled') } /** The trigger's box; `gap` is the room between its bottom and the viewport bottom. */ function triggerRect(trigger: Locator) { return trigger.evaluate((el) => { const box = el.getBoundingClientRect() return { top: box.top, bottom: box.bottom, gap: window.innerHeight - box.bottom } }) } /** One finger swipe on the page: `travel` > 0 moves the finger up (the page goes down). */ async function touchSwipe(page: Page, cdp: CDPSession, travel: number) { const from = 340 const point = (y: number) => [{ x: 200, y }] await cdp.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: point(from) }) for (let step = 1; step <= 10; step++) { const y = from - (travel * step) / 10 await cdp.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: point(y) }) } await cdp.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] }) return stableScrollY(page) } const CALIBRATION_TRAVELS = [120, 200] /** * Bounds the scroll one px of finger travel causes (measured 1.08 to 1.27); it is not the * fitted slope of `delta` on `travel` (about 1.54, which includes the offset). */ const CALIBRATION_GAIN_CEILING = 1.3 /** One swipe, answering its travel and the scroll it caused. */ async function measuredSwipe(page: Page, cdp: CDPSession, travel: number) { const before = await page.evaluate(() => window.scrollY) return { travel, delta: (await touchSwipe(page, cdp, travel)) - before } } const traceOf = (swipes: { travel: number; delta: number }[]) => swipes.map((swipe) => `${swipe.travel}->${swipe.delta}`).join(' ') /** Throws unless the calibration swipes fit before the target and the end of the page. */ async function expectCalibrationRoom(page: Page, target: number) { const room = await page.evaluate( () => document.documentElement.scrollHeight - window.innerHeight - window.scrollY, ) const needed = CALIBRATION_TRAVELS.reduce((sum, t) => sum + t, 0) * CALIBRATION_GAIN_CEILING if (needed >= target || needed >= room) { throw new Error(`calibration needs ~${needed} px, target ${target} px, scroll room ${room} px`) } } /** * Two swipes of known travel give the line `delta = gain * travel + offset` (touch slop and * Chromium's scroll gain). The page must have room for them before the target. */ async function calibrate(page: Page, cdp: CDPSession, target: number) { await expectCalibrationRoom(page, target) const swipes = [] for (const travel of CALIBRATION_TRAVELS) swipes.push(await measuredSwipe(page, cdp, travel)) const [near, far] = swipes const gain = (far.delta - near.delta) / (far.travel - near.travel) if (near.delta <= 0 || far.delta <= 0 || !(gain > 0.2)) { throw new Error(`touch calibration failed: gain=${gain}, swipes=${traceOf(swipes)}`) } return { line: { gain, offset: far.delta - gain * far.travel }, swipes } } /** * Scrolls by touch until the trigger's bottom is 0 to 4 px above the viewport bottom: each * swipe inverts the calibration for the distance left (aim: 2 px), a swipe back corrects an * overshoot. Throws, with the trace, when 8 swipes do not land it. */ async function scrollToWorstCase(page: Page, cdp: CDPSession, trigger: Locator) { const { line, swipes } = await calibrate(page, cdp, -(await triggerRect(trigger)).gap) for (let landing = 0; landing < 8; landing++) { const { gap } = await triggerRect(trigger) if (gap >= 0 && gap <= 4) { return `gain=${line.gain.toFixed(2)} offset=${line.offset.toFixed(1)} swipes=${traceOf(swipes)}` } const wanted = -gap - 2 const travel = Math.round((wanted - Math.sign(wanted) * line.offset) / line.gain) swipes.push(await measuredSwipe(page, cdp, travel)) } throw new Error(`the trigger never landed within 4 px: swipes=${traceOf(swipes)}`) } /** Whether the element is wholly on screen and the topmost thing at its centre. */ function probeInView(target: Locator) { return target.evaluate((el) => { const box = el.getBoundingClientRect() const at = document.elementFromPoint(box.x + box.width / 2, box.y + box.height / 2) const inside = box.top >= 0 && box.left >= 0 && box.bottom <= window.innerHeight && box.right <= window.innerWidth return { inside, hit: !!at && el.contains(at) } }) } /** The open panel's heading and close button, in view and hit-testable, no scroll needed. */ async function expectPanelReachable(page: Page) { const panel = page.locator('#editor-citations-panel') const heading = page.locator('#editor-citations-title') const close = panel.getByRole('button', { name: dict['editor.references.close'] }) const visible = await panel.evaluate( (el) => Math.min(el.getBoundingClientRect().bottom, window.innerHeight) - Math.max(el.getBoundingClientRect().top, 0), ) test.info().annotations.push({ type: 'c4-measure', description: `panel visible ${visible}` }) expect(visible).toBeGreaterThan(0) expect(await probeInView(heading), 'heading').toEqual({ inside: true, hit: true }) expect(await probeInView(close), 'close button').toEqual({ inside: true, hit: true }) } test.describe('editor shell layout (H)', () => { test.use({ locale: 'fr-FR', actionTimeout: 15_000 }) test.beforeEach(async ({ context }, info) => { test.skip(isPhone(info), 'the widths are set by the tests themselves') // 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('no horizontal scroll from 1 024 to 1 280 px on the five tabs, the three sections and the open citations panel', async ({ page, }) => { test.setTimeout(150_000) await open(page) for (const width of WIDTHS) { await page.setViewportSize({ width, height: 800 }) for (const tab of TABS) { await selectTab(page, dict, tab) await expectNoHorizontalOverflow(page, `${tab} at ${width} px`) } for (const section of SECTIONS) { await openSection(page, dict, section) await expectNoHorizontalOverflow(page, `${section} at ${width} px`) } await openCitations(page, dict, 'Constat A') await expectNoHorizontalOverflow(page, `the panel at ${width} px`) await closeCitations(page, dict) } }) test('the open panel is at most 34 rem and the viewport wide, and the document never changes size, before, during and after', async ({ page, }) => { test.setTimeout(150_000) await open(page) for (const width of WIDTHS) { await page.setViewportSize({ width, height: 800 }) await selectFinding(page, 'Constat A') const stop = await watchDocumentSize(page) await page.locator('[data-citations-trigger]:visible').click() await expect(page.locator('#editor-citations-title')).toBeFocused() await expectPanelWithin(page, width) await expectNoHorizontalOverflow(page, `the open panel at ${width} px`) await closeCitations(page, dict) const sizes = await stop() expect( sizes, `document size at ${width} px, before/during/after`, ).toHaveLength(1) } }) test('read-only at 320, 375 and 768 px: the five tabs fit and pass axe', async ({ page, requests, }) => { test.setTimeout(150_000) const actor = await editorActor('fr') requests.forbid(actor.account.email, actor.account.password) const seed = await seedDraft(actor, { shape: shapeWith(point) }) await signIn(page, actor.account, dict) await page.goto('/app/admin') await stepUpAdmin(page, dict, actor.secret) for (const width of NARROW_WIDTHS) { await page.setViewportSize({ width, height: 800 }) await page.goto(draftPath(seed.sheetId)) await expect( page.getByRole('heading', { level: 1, name: draftTitle(dict) }), ).toBeVisible() for (const tab of TABS) { await openTab(page, dict, tab) await expectNoHorizontalOverflow(page, `${tab} at ${width} px`) await expect( page.getByRole('button', { name: dict['common.save'], exact: true }), ).toHaveCount(0) if (width !== 320) await expectAccessible(page, `${tab} at ${width} px`) } for (const kind of ['undo', 'redo'] as const) { await expect(historyButton(page, dict, kind)).toHaveAttribute( 'aria-disabled', 'true', ) } } }) test('the canvas width is the same before the citations panel opens and after a tab switch closes it', async ({ page, }) => { test.setTimeout(150_000) await open(page) const measure = async () => (await page.getByTestId('annotation-canvas').boundingBox())?.width for (const width of WIDTHS) { await page.setViewportSize({ width, height: 800 }) await showDrawing(page, dict) await pickAnnotation(page, dict, 'Point libre') const before = await measure() test.info().annotations.push({ type: 'canvas-width', description: `${before}px at ${width}px`, }) await openCitations(page, dict, 'Constat A') // The panel exists on Constats only: leaving for Annotations closes it (P21). await selectTab(page, dict, 'annotations') await expect(place(page, 'citations')).toHaveCount(0) await expect(page.getByTestId('annotation-canvas')).toBeVisible() expect(await measure()).toBe(before) } }) test('axe from the top on the five tabs, each section and the open citations panel', async ({ page, }) => { test.setTimeout(150_000) await open(page) for (const width of [1024, 1280]) { await page.setViewportSize({ width, height: 800 }) const places: (readonly [string, () => Promise])[] = [ ...TABS.map((tab) => [tab, () => selectTab(page, dict, tab)] as const), ...SECTIONS.map( (section) => [section, () => openSection(page, dict, section)] as const, ), ] for (const [name, show] of places) { await show() await settle(page) await page.evaluate(() => window.scrollTo(0, 0)) await expect(page.locator('dialog[open]')).toHaveCount(0) await expectAccessible(page, `${name} at ${width} px`) } await openCitations(page, dict, 'Constat A') await settle(page) await page.evaluate(() => window.scrollTo(0, 0)) await expect(page.locator('dialog[open]')).toHaveCount(0) await expectAccessible(page, `the open panel at ${width} px`) await closeCitations(page, dict) } }) for (const width of WIDTHS) { test(`the history buttons stay reachable at the top of the page at ${width} px`, async ({ page, }) => { await open(page) await page.setViewportSize({ width, height: 800 }) await page.evaluate(() => window.scrollTo(0, 0)) for (const kind of ['undo', 'redo'] as const) { const hit = await historyButton(page, dict, kind).evaluate((button) => { const box = button.getBoundingClientRect() const at = document.elementFromPoint( box.x + box.width / 2, box.y + box.height / 2, ) return { top: box.y, covered: !at || !button.contains(at) } }) test.info().annotations.push({ type: 'history-button-top', description: `${kind} y=${hit.top} at ${width}px covered=${hit.covered}`, }) expect(hit.covered, `${kind} at ${width} px`).toBe(false) } }) } }) type Kind = | 'header' | 'tab' | 'undo' | 'redo' | 'panel' | 'tools' | 'canvas' | 'side' | 'other' /** What the focused element is, in the words of the keyboard order of AC17. */ function focusKind(page: Page): Promise { return page.evaluate((undoName) => { const el = document.activeElement if (!el) return 'other' if (el.closest('[data-place="citations"]')) return 'panel' if (el.getAttribute('role') === 'tab') return 'tab' if (el.closest('[data-testid="history-buttons"]')) { return el.getAttribute('aria-label') === undoName ? 'undo' : 'redo' } if (el.closest('main header')) return 'header' if (el.closest('[role="toolbar"]')) return 'tools' if (el.closest('[data-testid="annotation-canvas"]')) return 'canvas' if (el.closest('[data-testid="annotation-overview"]')) return 'side' if (el.closest('[data-testid="annotation-properties"]')) return 'side' return 'other' }, dict['editor.history.undo_title']) } /** Tabs forward from the page heading until `stop` is reached; the kinds met, without repeats. */ async function walk(page: Page, stop: Kind): Promise { await page.getByRole('heading', { level: 1, name: draftTitle(dict) }).focus() const seen: Kind[] = [] for (let step = 0; step < 60; step++) { await page.keyboard.press('Tab') const kind = await focusKind(page) if (kind !== 'other' && seen[seen.length - 1] !== kind) seen.push(kind) if (kind === stop) break } return seen } test.describe('editor shell keyboard order (H)', () => { test.use({ locale: 'fr-FR', actionTimeout: 15_000 }) test.beforeEach(async ({ context }, info) => { test.skip(isPhone(info), 'keyboard order is checked at one width') // 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) }) // The header holds no focusable control after the title while the draft is clean: its // buttons (« Abandonner », « Enregistrer ») are disabled, and « Références » left it. test('tab list, Défaire, Refaire, then the tools, the canvas and the side column', async ({ page, }) => { await open(page) await selectTab(page, dict, 'annotations') await expect(page.getByTestId('annotation-canvas')).toBeVisible() const order = await walk(page, 'side') test.info().annotations.push({ type: 'keyboard-order', description: order.join(' > '), }) expect(order).toEqual(['tab', 'undo', 'redo', 'tools', 'canvas', 'side']) }) test('with the panel open: tab list, Défaire, Refaire, the panel, then the page content', async ({ page, }) => { await open(page) await openCitations(page, dict, 'Constat A') const order = await walk(page, 'panel') test.info().annotations.push({ type: 'keyboard-order-panel', description: order.join(' > '), }) expect(order).toEqual(['tab', 'undo', 'redo', 'panel']) await page.keyboard.press('Escape') await expect(page.locator('[data-place="citations"]:visible')).toHaveCount( 0, ) await selectTab(page, dict, 'annotations') const after = await walk(page, 'side') expect(after.slice(0, 3)).toEqual(['tab', 'undo', 'redo']) expect(after).not.toContain('panel') expect(after.at(-1)).toBe('side') }) }) test.describe('citations panel at 375 px, read-only (O4-2)', () => { test.use({ locale: 'fr-FR', actionTimeout: 15_000 }) test.beforeEach(async ({ context }, info) => { test.skip(!isPhone(info), 'the phone sizes are set by the test itself') await routeToSandbox(context) }) test.afterEach(async ({ context }) => { await dropLateReplays(context) }) test('full width, never wider than the screen, bottom on the viewport bottom through a height change and a rotation, the drawing box unchanged @phone', async ({ page, }) => { test.setTimeout(150_000) await open(page) await openTab(page, dict, 'annotations') const drawingBox = () => place(page, 'annotations.drawing').boundingBox() await expect(place(page, 'annotations.drawing')).toBeVisible() const drawing = await drawingBox() await selectFinding(page, 'Constat A') await page.locator('[data-citations-trigger]:visible').click() await expect(page.locator('#editor-citations-title')).toBeFocused() for (const size of [ { width: 375, height: 667 }, { width: 375, height: 560 }, { width: 667, height: 375 }, ]) { await page.setViewportSize(size) await page.evaluate( () => new Promise((done) => requestAnimationFrame(() => done(null))), ) await expectPanelWithin(page, size.width, size.width === 667) await expectNoHorizontalOverflow( page, `the panel at ${size.width} x ${size.height}`, ) } await page.setViewportSize({ width: 375, height: 667 }) await closeCitations(page, dict) await openTab(page, dict, 'annotations') await expect(place(page, 'annotations.drawing')).toBeVisible() expect(await drawingBox()).toEqual(drawing) }) test('667 x 375 by touch: the trigger is reached, the panel stays in view @phone', async ({ page, }) => { test.setTimeout(150_000) await open(page) await page.setViewportSize({ width: 667, height: 375 }) await tapFinding(page, 'Constat A') const trigger = page.locator('[data-citations-trigger]:visible') await expect(trigger).toBeVisible() await page.evaluate(() => window.scrollTo(0, 0)) await settle(page) const start = await triggerRect(trigger) const cdp = await page.context().newCDPSession(page) const log = await scrollToWorstCase(page, cdp, trigger) const end = await triggerRect(trigger) const reached = await stableScrollY(page) test.info().annotations.push({ type: 'c4-measure', description: `top=${start.top} bottom=${start.bottom}; ${log}; gap=${end.gap} y=${reached}`, }) expect(end.gap, 'trigger gap to the viewport bottom').toBeGreaterThanOrEqual(0) expect(end.gap, 'trigger gap to the viewport bottom').toBeLessThanOrEqual(4) expect(end.top, 'trigger top on screen').toBeGreaterThanOrEqual(0) expect(await probeInView(trigger), 'trigger hit-testable').toMatchObject({ hit: true }) await trigger.tap() await expect(page.locator('#editor-citations-title')).toBeFocused() expect(await stableScrollY(page), 'no scroll once the panel is open').toBe(reached) await expectPanelReachable(page) }) test('the document size does not change while the panel opens and closes @phone', async ({ page, }) => { test.setTimeout(150_000) await open(page) await selectFinding(page, 'Constat A') const stop = await watchDocumentSize(page) await page.locator('[data-citations-trigger]:visible').click() await expect(page.locator('#editor-citations-title')).toBeFocused() await closeCitations(page, dict) expect(await stop()).toHaveLength(1) }) })