Files
bchanot ba3a51e1b8 test(app): scope known axe exceptions to their markup and route
Each pre-existing exception (RR-7) now matches the axe rule, the selector,
the element's opening markup and its route; a new screen or element never
inherits one. Failure lines name the route.
2026-10-26 01:02:54 +01:00

221 lines
6.9 KiB
TypeScript
Raw Permalink 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.
/**
* Shared pieces of the Playwright suites (docs/development/BROWSER_TESTS.md):
* the two Chromium projects, the request guard every test runs under, the axe
* gate, and the focus and layout probes.
*/
import AxeBuilder from '@axe-core/playwright'
import {
devices,
expect,
test as base,
type Page,
type Project,
} from '@playwright/test'
/**
* Desktop and the 375 × 667 phone of the V1-1 contract (§12.5); Chromium only
* until V1-5. A test tagged `@phone` covers what exists on small screens only.
*/
export const PROJECTS: Project[] = [
{
name: 'chromium-desktop',
grepInvert: /@phone/,
use: {
...devices['Desktop Chrome'],
viewport: { width: 1280, height: 800 },
},
},
{
name: 'chromium-375',
use: {
...devices['Desktop Chrome'],
viewport: { width: 375, height: 667 },
deviceScaleFactor: 2,
isMobile: true,
hasTouch: true,
},
},
]
export interface GuardOptions {
/** Origins the page may reach; every other request is aborted and fails the test. */
allowedOrigins: string[]
/** Strings no request URL may carry (fixture names, emails, search terms). */
forbiddenInUrls: string[]
}
export interface RequestGuard {
/** Adds values made during the test (a fictitious account) to `forbiddenInUrls`. */
forbid: (...values: string[]) => void
}
/**
* Every test runs under a request guard: a request to an origin outside the
* allowlist (the DEV stack, a CDN, anything) is aborted, and the test fails
* listing it, as it fails on a URL holding a fixture value (masked in the
* report, which never shows the value itself).
*/
export const test = base.extend<GuardOptions & { requests: RequestGuard }>({
allowedOrigins: [[], { option: true }],
forbiddenInUrls: [[], { option: true }],
requests: [
async ({ context, allowedOrigins, forbiddenInUrls }, use) => {
const forbidden = forbiddenInUrls.filter((value) => value !== '')
const refused: string[] = []
const leaking: string[] = []
const mask = (url: string) =>
forbidden.reduce(
(masked, value) => masked.replaceAll(value, '<fixture>'),
url,
)
await context.route(
(url) => !allowedOrigins.includes(url.origin),
(route) => {
refused.push(mask(decodeURIComponent(route.request().url())))
return route.abort('blockedbyclient')
},
)
context.on('request', (request) => {
const url = decodeURIComponent(request.url())
if (forbidden.some((value) => url.includes(value)))
leaking.push(mask(url))
})
await use({
forbid: (...values) =>
forbidden.push(...values.filter((v) => v !== '')),
})
expect(refused, 'requests outside the allowed origins').toEqual([])
expect(leaking, 'request URLs carrying a fixture value').toEqual([])
},
{ auto: true },
],
})
export { expect }
/**
* Serious violations found before V1-1.3, outside its code, listed in TODO RR-7
* until their own fix: the scan lets through only the node that matches the
* rule, the selector, the opening markup and the route of each entry, and fails
* on any other, so a new screen or a new element never inherits an exception
* (WCAG 2.5.3 label in name, 1.3.1 info and relationships).
*/
const KNOWN_VIOLATIONS: {
id: string
target: RegExp
html: RegExp
path: RegExp
note: string
}[] = [
{
id: 'label-content-name-mismatch',
target: /^button\[aria-label="(Passer en français|Switch to English)"\]$/,
html: /^<button [^>]*aria-label="(Passer en français|Switch to English)"/,
path: /^\//,
note: 'LanguageSwitcher (every page): shows « FR » / « EN », named « Passer en français » / « Switch to English »',
},
{
id: 'label-content-name-mismatch',
target: /^\.pr-1$/,
html: /^<a [^>]*href="\/app\/account"/,
path: /^\/app(\/|$)/,
note: 'AppLayout top bar account link: shows the display name, named « Mon compte » / « My account »',
},
{
id: 'definition-list',
target: /^dl$/,
html: /^<dl class="grid gap-2 text-sm">/,
path: /^\/app\/?$/,
note: 'DashboardRoute account card: the verified-status row is a div without dt/dd inside the dl',
},
]
const isKnown = (id: string, target: string, html: string, path: string) =>
KNOWN_VIOLATIONS.some(
(known) =>
known.id === id &&
known.target.test(target) &&
known.html.test(html) &&
known.path.test(path),
)
/**
* Zero serious or critical axe violation on the page as it stands (WCAG 2.0 to
* 2.2 A and AA rules plus axe best practices), known ones aside; the failure
* message lists them.
*/
export async function expectAccessible(
page: Page,
state: string,
): Promise<void> {
// Colours are measured at rest: an entrance animation still running would blend them.
await page.waitForFunction(() =>
document
.getAnimations()
.every((animation) => animation.playState !== 'running'),
)
const { violations } = await new AxeBuilder({ page })
.withTags([
'wcag2a',
'wcag2aa',
'wcag21a',
'wcag21aa',
'wcag22aa',
'best-practice',
])
.analyze()
const path = new URL(page.url()).pathname
const blocking = violations
.filter((v) => v.impact === 'serious' || v.impact === 'critical')
.flatMap((v) =>
v.nodes
.filter(
(node) => !isKnown(v.id, node.target.join(' '), node.html, path),
)
.map(
(node) =>
`${v.impact} ${v.id}: ${v.help} → ${node.target.join(' ')} on ${path}`,
),
)
expect(blocking, `axe on ${state}`).toEqual([])
}
/**
* Where the focus is: in the open modal dialog, in the browser's own interface
* (the document lost focus, as Tab past a modal dialog's last control does), or
* on something else of the page.
*/
export function focusOwner(page: Page): Promise<string> {
return page.evaluate(() => {
const active = document.activeElement
if (!document.hasFocus()) return 'browser'
if (!active || active === document.body) return 'body'
if (active.closest('dialog:modal')) return 'dialog'
return `outside:${active.tagName.toLowerCase()}:${active.textContent?.trim().slice(0, 40)}`
})
}
/** Accessible name of the focused element (aria-label, else its text). */
export function focusedName(page: Page): Promise<string> {
return page.evaluate(() => {
const active = document.activeElement as HTMLElement | null
return (
active?.getAttribute('aria-label') ?? active?.textContent?.trim() ?? ''
)
})
}
/** No horizontal page scroll: the document is no wider than the viewport. */
export async function expectNoHorizontalOverflow(
page: Page,
state: string,
): Promise<void> {
const { scrollWidth, clientWidth } = await page.evaluate(() => ({
scrollWidth: document.documentElement.scrollWidth,
clientWidth: document.documentElement.clientWidth,
}))
expect(scrollWidth, `horizontal overflow on ${state}`).toBeLessThanOrEqual(
clientWidth,
)
}