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.
221 lines
6.9 KiB
TypeScript
221 lines
6.9 KiB
TypeScript
/**
|
||
* 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,
|
||
)
|
||
}
|