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) } /** Finger travel of each reach swipe, well above the touch slop (a swipe <= ~60 px moves 0). */ const REACH_TRAVEL = 200 const REACH_MAX_SWIPES = 12 /** * Swipes by touch only until the trigger is wholly on screen and hit-testable. Answers the * swipe count; throws with the scrollY trace after REACH_MAX_SWIPES swipes. */ async function swipeUntilReached( page: Page, cdp: CDPSession, trigger: Locator, ) { const trace: number[] = [] for (let swipes = 0; swipes <= REACH_MAX_SWIPES; swipes++) { const view = await probeInView(trigger) if (view.inside && view.hit) return swipes if (swipes < REACH_MAX_SWIPES) trace.push(await touchSwipe(page, cdp, REACH_TRAVEL)) } throw new Error( `the trigger never came into view: scrollY after each swipe ${trace.join(' ')}`, ) } /** Scrolls at once so the trigger's bottom sits on the viewport bottom (clamped to the page). */ async function scrollToWorstCase(page: Page, trigger: Locator) { await trigger.evaluate((el) => { const max = document.documentElement.scrollHeight - window.innerHeight const want = window.scrollY + el.getBoundingClientRect().bottom - window.innerHeight window.scrollTo({ top: Math.min(Math.max(Math.ceil(want), 0), max), behavior: 'instant', }) }) return stableScrollY(page) } /** Taps the trigger: the panel opens with heading and close in view, the page does not scroll. */ async function tapOpensInPlace(page: Page, trigger: Locator, scrollY: number) { expect(await probeInView(trigger), 'trigger in view').toEqual({ inside: true, 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( scrollY, ) await expectPanelReachable(page) } /** 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: reached by touch; at the worst case 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)) expect(await stableScrollY(page), 'start at the top').toBe(0) const start = await triggerRect(trigger) // A. Reachability by touch swipes only (CDP touch events, no keyboard, no programmatic scroll). const cdp = await page.context().newCDPSession(page) const swipes = await swipeUntilReached(page, cdp, trigger) const reached = await stableScrollY(page) expect(reached, 'the page scrolled by touch').toBeGreaterThan(0) await tapOpensInPlace(page, trigger, reached) const close = page.getByRole('button', { name: dict['editor.references.close'], }) await close.tap() await expect(place(page, 'citations')).toHaveCount(0) // B. Worst case: the trigger's bottom exactly on the viewport bottom. Set by window.scrollTo // because touch has a slop floor and a load-dependent gain, so a pixel-exact touch landing // is not deterministic; A already proves the trigger is reachable by touch. const worst = await scrollToWorstCase(page, trigger) const end = await triggerRect(trigger) test.info().annotations.push({ type: 'c4-measure', description: `top=${start.top} bottom=${start.bottom}; A swipes=${swipes} y=${reached}; ` + `B gap=${end.gap} y=${worst}`, }) expect( end.gap, 'trigger gap to the viewport bottom', ).toBeGreaterThanOrEqual(0) expect(end.gap, 'trigger gap to the viewport bottom').toBeLessThanOrEqual(1) await tapOpensInPlace(page, trigger, worst) }) 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) }) })