API-referentie voor de JavaScript- en TypeScript-versie van Watcher

Deze referentiegids beschrijft de API's die worden aangeboden door het @axe-core/watcher-pakket (ook wel aangeduid als Axe Watcher of gewoon Watcher) voor JavaScript en TypeScript.

AxeConfiguration Interface

De axe-eigenschap (een parameter die wordt doorgegeven aan de configuratiefuncties) is het gebruikelijke middel om je AxeConfiguration voor Axe Watcher te wijzigen om toegankelijkheidstests te configureren. De volgende eigenschappen zijn opgenomen in AxeConfiguration:

apiKey

(Verplicht) De apiKey-waarde is een van de twee eigenschappen (apiKey en projectId) die moeten worden ingesteld in je AxeConfiguration. Je kunt de waarde verkrijgen van de Beheer API-sleutelpagina .

axe: {
  apiKey: process.env.AXE_DEVELOPER_HUB_API_KEY
}

autoAnalyze

(Optioneel) Stel deze waarde in op false om te voorkomen dat pagina's automatisch worden geanalyseerd. Voor meer informatie over de handmatige modus, zie Beheer Je Scans.

axe: {
  autoAnalyze: false
}

buildID

(Optional) The buildID property, when not null, allows parallel test runners to generate results that appear as a single test run in axe Developer Hub. In the case of parallel test runs, each test runner should share the same non-null buildID string, which causes each test run to concatenate its results with existing results for the same buildID and Git commit SHA. However, when buildID is null, multiple test runs **overschrijven** existing results that have the same Git commit SHA.

Zie Tests In Parallel Uitvoeren voor meer informatie over hoe buildID te gebruiken met verschillende continue integratieproviders.

axe: {
  buildID: process.env.CI_BUILD_ID
}

configurationOverrides

(Optioneel) Overschrijft waarden die zijn ingesteld in de globale configuratie. Zie de ConfigurationOverrides Interface voor meer informatie.

axe: {
  configurationOverrides: {
    accessibilityStandard: 'WCAG 2.2 AA',
    bestPractices: true
  }
}

elementInternals

(Optioneel) Wanneer true, verzamelt Watcher ARIA-rollen en -eigenschappen ingesteld via de ElementInternals API van aangepaste elementen die attachInternals() gebruiken. Dit vermindert false positives op pagina's die gebruikmaken van aangepaste elementen voor interactieve componenten. Vereist axe-core versie 4.12.0 of later.

axe: {
  elementInternals: true
}

excludeUrlPatterns

(Optioneel) Voorkomt dat een URL die overeenkomt met een van de minimatch-patronen in de excludeUrlPatterns-array wordt geanalyseerd.

axe: {
  excludeUrlPatterns: [ 'https://*.example.com/**', 'https://example.org/**' ]
}

In URL's Uitsluiten van Analyse kun je een tabel vinden met URL's en voorbeeldpatronen om overeenkomsten te verifiëren.

git

(Optioneel) Bepaalt hoe Watcher Git-metadata verzamelt voor de huidige testrun. Accepteert een van de drie waarden:

• true (standaard): Watcher verzamelt automatisch Git-informatie (branch, commit SHA, auteur en andere velden) met behulp van de lokale Git-binair.
• false: Schakelt alle Git-metadata-verzameling uit. Gebruik dit bij uitvoering in omgevingen zonder Git of wanneer Git-gegevensverzameling niet nodig is.
• Een GitConfig-object: Voorziet expliciete Git-metadata en slaat auto-detectie volledig over. Velden die je weglaat, hebben als standaard null. Gebruik dit wanneer je tests uitvoert in een repository die gescheiden is van de repository die wordt getest, of in CI-omgevingen waar Git-auto-detectie onbetrouwbaar is.

Zie Git-metadata verstrekken voor meer informatie.

Het GitConfig-object heeft de volgende velden:

branch, commitSha, en url zijn de gitful-velden: een sessie ingediend zonder alle drie wordt geregistreerd als gitloos en opgeslagen, maar Axe Developer Hub schakelt over naar de gitless sessie-weergave, waarin de branch- en commitgeschiedenis van vorige sessies niet zichtbaar zal zijn. Het indienen van een volgende sessie met alle drie velden herstelt de gitful-weergave. Als slechts één of twee van de drie aanwezig zijn, laat Axe Watcher alle gitful-velden vallen, registreert de sessie als gitless en voegt een waarschuwing toe in de reactie.

Voorbeeld van het gebruik van CI-omgevingsvariabelen om expliciete Git-metadata te verschaffen:

axe: {
  apiKey: process.env.AXE_DEVELOPER_HUB_API_KEY,
  projectId: process.env.AXE_PROJECT_ID,
  git: {
    commitSha: process.env.GIT_COMMIT,
    branch: process.env.GIT_BRANCH,
    url: process.env.GIT_URL,
    commitAuthor: process.env.GIT_AUTHOR_NAME,
    commitEmail: process.env.GIT_AUTHOR_EMAIL,
    commitMessage: process.env.GIT_COMMIT_MESSAGE,
    defaultBranch: 'main'
  }
}

projectId

(Verplicht) Geeft het project-ID op dat de Watcher toegankelijkheidsresultaten zal ontvangen. Je project-ID wordt getoond bij de instructies wanneer je een nieuw project maakt, en je kunt het ook verkrijgen van de axe Developer Hub Projectenpagina .

axe: {
  projectId: process.env.AXE_PROJECT_ID
}

runContext

(Optioneel) Hiermee kunt u kiezen welke elementen wel of niet worden opgenomen in de toegankelijkheidsanalyse van uw pagina.

De waarde van runContext kan zijn:

1. Een enkele CSS-selector voor elementen die in de analyse worden opgenomen:

   axe: {
     runContext: '.main'
   }

2. Een array van CSS-selectors voor elementen die in de analyse worden opgenomen:

   axe: {
     runContext: [ '.main', '.text-block' ]
   }

3. Een contextobject met include en exclude-eigenschappen (zoals getoond in het bovenstaande voorbeeld). Je kunt include of exclude of beide specificeren. Elke include of exclude kan een enkele CSS-selector of een array van CSS-selectors zijn:

   axe: {
     runContext: {
       include: '.main',
       exclude: '.ad-section'
     }
   }

Meer details zijn beschikbaar in de axe-core Context documentatie.

runOptions

(Optioneel) Het runOptions-object staat de volgende subset van eigenschappen toe van het axe-core Options-type:

• ancestry: Standaard is false. Indien true, bevatten de geretourneerde CSS-selectors de bovenliggende elementen van de geretourneerde elementen.

  important

  Als je pagina dynamische ID's of klassen gebruikt (element-ID's of klassen die elke keer dat de pagina wordt herladen veranderen), moet je ancestry als true specificeren, zodat Axe Developer Hub correct kan detecteren en volgen of toegankelijkheidsproblemen zijn duplicaten omdat, standaard, Axe Developer Hub verwacht dat element-ID's en klassen hetzelfde blijven tussen testuitvoeringen.

  Wanneer ancestry true is, gebruikt Axe Developer Hub in plaats daarvan de positie van het element binnen de DOM-boom om hetzelfde element tussen testuitvoeringen te lokaliseren.

  Het volgende toont een voorbeeld van een selector wanneer ancestry false is voor een iframe-element met een ID van *main-iframe* (<iframe id="main-iframe" ...>):

  iframe#main-iframe

  Als ancestry true is, zou de selector het gehele pad vanaf het rootelement omvatten, en zijn er geen ID's of klassen gespecificeerd:

  html > body > div:nth-child(20) > div:nth-child(1) > div > div > ul > li:nth-child(1) > div > span > iframe

• runOnly: Hiermee kun je beperken welke regels worden uitgevoerd door namen of tags op te geven. Zie runOnly hieronder voor meer informatie.

• rules: Schakel regels in of uit met behulp van de enabled-eigenschap. Zie rules hieronder voor meer informatie.

Het volgende toont een voorbeeld van runOptions:

axe: {
  runOptions: {
    ancestry: true,
    runOnly: {
      type: 'tag',
      values: [ 'wcag2a' ]
    },
    rules: {
      'ruleId1': { enabled: false },
      'ruleId2': { enabled: false }
    }
  }
}

runOnly

De waarde runOnly (deel van het runOptions object) kan een van de volgende zijn:

1. Een tekenreeks die de regel-ID vertegenwoordigt van de regel die u wilt gebruiken voor toegankelijkheidsanalyse:

   axe: {
     runOptions: {
       runOnly: 'ruleId'
     }
   }

2. Een array van tekenreeksen die de regel-IDs vertegenwoordigen van de regels die u wilt gebruiken:

   axe: {
     runOptions: {
       runOnly: [ 'ruleId1', 'ruleId2' ]
     }
   }

3. Een object met type en values eigenschappen. De waarde type is een string die rule, rules, tag of tags kan zijn. De eigenschap values moet een array van strings zijn die de regel(s) of tag(s) vertegenwoordigen die u wilt gebruiken voor toegankelijkheidsanalyse. Het volgende voorbeeld toont het gebruik van het runOnly object om toegankelijkheidstesten te beperken tot regels getagd als wcag2a:

   axe: {
     runOptions: {
       runOnly: {
         type: 'tag',
         values: [ 'wcag2a' ]
       }
     }  
   }

• Voor meer voorbeelden van runOnly gebruik (met axe-core), zie Optieparameter Voorbeelden
• Voor meer informatie over beschikbare tagwaarden, zie axe-core Tags.
• Voor informatie over de regels, regel-ID's en tags, zie Regelbeschrijvingen

rules

De waarde rules (op het runOptions object) stelt u in staat om specifieke regels tijdens de analyse in te schakelen (enabled: true) of uit te schakelen (enabled: false), zoals hieronder weergegeven:

axe: {
  runOptions: {
    rules: {
      'ruleId1': { enabled: false },
      'ruleId2': { enabled: false }
    }
  }
}

serverURL

(Optioneel) De URL van de Axe Developer Hub server naar welke Watcher toegankelijkheidsresultaten verstuurt. Standaard is ingesteld op https://axe.deque.com.

U hoeft deze waarde niet in te stellen als uw project is aangemaakt op axe.deque.com. Echter, als uw organisatie een regionale instantie, private cloud, of on-premises implementatie van Axe Developer Hub gebruikt, stel dan serverURL in op de basis-URL van die instantie:

axe: {
  apiKey: process.env.ACCESSIBILITY_API_KEY,
  projectId: process.env.PROJECT_ID,
  serverURL: process.env.SERVER_URL // e.g., 'https://axe-eu.deque.com'
}

sessionId

(Optioneel) De eigenschap sessionId is verouderd en moet niet worden gebruikt. Zie buildID hierboven.

testingTypes

(Optioneel) De eigenschap testingTypes is een array van strings te gebruiken met Cypress voor het specificeren van component of e2e (end-to-end) testen (of beide).

axe: {
  testingTypes: ['e2e', 'component']
}

timeout

(Optioneel) Het timeout object (van type Timeouts) in AxeConfiguration stelt de time-outwaarden in milliseconden in voor de respectieve controller methoden (of aangepaste commando's voor Cypress). (Zie de Controller Klassen voor informatie over de controllerklassen en de Cypress Aangepaste Commentaren voor informatie over Cypress aangepaste commando's.) Wanneer een time-out verloopt, faalt de test met een bericht dat aangeeft dat de time-out overschreden is. U kunt de time-out verhogen om de fout te vermijden.

Dit voorbeeld stelt de analyze time-out in op 8 seconden, flush op 15 seconden, start op 10 seconden, en stop op 10 seconden. (De standaardwaarden staan in de tabel onder Timeouts Interface.)

axe: {
  timeout: {
    analyze: 8000,
    flush: 15000,
    start: 10000,
    stop: 10000,
  }
}

Configuratiefuncties

De configuratiefuncties die door Watcher worden geboden, stellen u in staat om uw setup aan te passen voor het gespecificeerde testframework en hoe u Watcher wilt uitvoeren naar uw wensen aan te passen. Zie AxeConfiguration-interface voor meer informatie.

cypressConfig

Maakt een configuratie voor Cypress.

cypressConfig(config: Cypress.ConfigOptions & Configuration): Cypress.ConfigOptions

cypressConfig Parameters

• config: Cypress.ConfigOptions & Configuration

  Kruispunttype van Cypress.ConfigOptions en Configuration.

Retourneert: Cypress.ConfigOptions

cypressConfig Voorbeeld

import { defineConfig } from 'cypress'
import { cypressConfig } from '@axe-core/watcher/cypress/config'

export default defineConfig(
  cypressConfig({
    axe: {
      apiKey: process.env.API_KEY,
      projectId: process.env.PROJECT_ID
    }
  })
)

playwrightConfig

Maakt een configuratie voor Playwright.

playwrightConfig(opts: Configuration & LaunchOptions): LaunchOptions

playwrightConfig Parameters

• opts: Configuration & LaunchOptions

  Kruispunttype van LaunchOptions en Configuration.

Retourneert: LaunchOptions

playwrightConfig Voorbeeld

import { chromium } from 'playwright'
import { playwrightConfig } from '@axe-core/watcher/playwright'

const browserContext = await chromium.launchPersistentContext(
  '',
  playwrightConfig({
    axe: {
      apiKey: process.env.API_KEY,
      projectId: process.env.PROJECT_ID
    }
  })
)

playwrightTest

Maakt een configuratie voor Playwright Test.

playwrightTest(options: Options): ReturnValue

playwrightTest Parameters

• options: Options

  Options is een kruispunttype van Configuration en LaunchOptions.

Retourneert: ReturnValue

playwrightTest Voorbeeld

// fixtures.ts
import { playwrightTest } from '@axe-core/watcher/playwright-test'

export default playwrightTest({
  axe: {
    apiKey: process.env.API_KEY,
    projectId: process.env.PROJECT_ID
  }
})

puppeteerConfig

Maakt een configuratie voor Puppeteer.

puppeteerConfig(opts: Configuration & LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions): Options

puppeteerConfig Parameters

• opts: Configuration & LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions

  Kruispunttype van LaunchOptions, BrowserLaunchArgumentOptions, BrowserConnectOptions en Configuration.

Retourneert: Options

puppeteerConfig Voorbeeld

import puppeteer from 'puppeteer'
import { puppeteerConfig } from '@axe-core/watcher/puppeteer'

const browser = await puppeteer.launch(
  puppeteerConfig({
    axe: {
      apiKey: process.env.API_KEY,
      projectId: process.env.PROJECT_ID
    }
  })
)

wdioConfig

Maakt een WebdriverIO-configuratie.

wdioConfig({ axe, ...options}: Options): RemoteOptions

wdioConfig Parameters

• arg: Options

  Options is een kruispunttype van RemoteOptions en Configuration.

Retourneert: RemoteOptions

wdioConfig Voorbeeld

import { remote } from 'webdriverio'
import { wdioConfig } from '@axe-core/watcher/wdio'

const browser = await remote(
  wdioConfig({
    axe: {
      apiKey: process.env.API_KEY,
      projectId: process.env.PROJECT_ID
    },
    capabilities: { browserName: 'chrome' }
  })
)

wdioTestRunner

Maakt een WebdriverIO Testrunner-configuratie.

wdioTestRunner(...params: unknown[]): Options.Testrunner

wdioTestRunner Parameters

• params: unknown[]

  De waarde params is een van:

  1. Een array die één waarde bevat, namelijk een kruispunttype van Options.Testrunner en Configuration.
  2. Een array waarbij de eerste arraywaarde een AxeConfiguration is en de tweede waarde een Options.Testrunner is.

Retourneert: Options.Testrunner

wdioTestRunner Voorbeeld

import { wdioTestRunner } from '@axe-core/watcher/wdio'

export const config = wdioTestRunner({
  axe: {
    apiKey: process.env.API_KEY,
    projectId: process.env.PROJECT_ID
  }
})

webdriverConfig

Creëert een Selenium WebDriver-configuratie.

webdriverConfig(arg: WebDriverArgs): Options

webdriverConfig Parameters

• arg: WebDriverArgs

  Een Configuration uitgebreid met een Selenium WebDriver Options lid.

Retourneert: Options

webdriverConfig Voorbeeld

import { Builder } from 'selenium-webdriver'
import { Options } from 'selenium-webdriver/chrome'
import { webdriverConfig } from '@axe-core/watcher/webdriver'

const options = new Options()
const browser = await new Builder()
  .forBrowser('chrome')
  .setChromeOptions(
    webdriverConfig({
      axe: {
        apiKey: process.env.API_KEY,
        projectId: process.env.PROJECT_ID
      },
      options
    })
  )
  .build()

Configuration Interface

De Configuration interface wordt gebruikt met de configuratiefuncties en bevat één eigenschap:

Al deze configuratiefuncties gebruiken deze axe eigenschap om je in staat te stellen Watcher in te stellen en je toegankelijkheidstests te configureren. Zie de AxeConfiguration-interface sectie hierboven voor meer informatie.

ConfigurationOverrides Interface

De ConfigurationOverrides interface stelt je in staat om de wereldwijde configuratie-instellingen van je organisatie voor individuele testuitvoeringen te overschrijven. Deze eigenschap moet worden gebruikt in overeenstemming met de machtigingen die zijn ingesteld in de wereldwijde configuratie van je bedrijf.

accessibilityStandard

Stelt de toegankelijkheidsstandaard vast waartegen moet worden getest. Beschikbare opties:

• ‘Alles’ - Test tegen alle beschikbare standaarden
• ‘WCAG 2.2 AAA’
• ‘WCAG 2.2 AA’
• ‘WCAG 2.2 A’
• ‘WCAG 2.1 AAA’
• ‘WCAG 2.1 AA’
• ‘WCAG 2.1 A’
• ‘WCAG 2.0 AAA’
• ‘WCAG 2.0 AA’
• ‘WCAG 2.0 A’
• ‘Trusted Tester v5’
• ‘EN 301 549’
• ‘RGAAv4’ - RGAA versie 4 (Franse toegankelijkheidsstandaard; vereist axe-core 4.11.0 of later)

Uw organisatie moet toestaan dat deze instelling in de globale configuratie kan worden overschreven, en de gekozen standaard moet behoren tot de toegestane opties.

axe: {
  configurationOverrides: {
    accessibilityStandard: 'WCAG 2.2 AA'
  }
}

axeCoreVersion

Specificeert welke versie van axe-core gebruikt moet worden voor testen. Beschikbare opties zijn onder andere:

• ‘latest’ - Laatst ondersteunde versie die momenteel is gebundeld met Axe Watcher
• Specifieke versies vanaf 4.4.0 en later (bijv. ‘4.10.2’, ‘4.9.1’, enz.)

Uw organisatie moet toestaan dat deze instelling in de globale configuratie kan worden overschreven, en de gekozen versie moet behoren tot de toegestane opties.

axe: {
  configurationOverrides: {
    axeCoreVersion: 'latest'
  }
}

bestPractices

Schakelt best practice-richtlijnen in of uit voor de testuitvoering. Beste praktijken verbeteren de toegankelijkheid, maar maken geen deel uit van formele standaarden. Je organisatie moet toestaan dat deze instelling kan worden overschreven voordat dit effect heeft.

axe: {
  configurationOverrides: {
    bestPractices: true
  }
}

experimentalRules

Schakelt experimentele regels in of uit voor de testuitvoering. Experimentele regels zijn nog in ontwikkeling en kunnen valse positieven opleveren. Je organisatie moet toestaan dat deze instelling kan worden overschreven in de globale configuratie voordat dit effect heeft.

axe: {
  configurationOverrides: {
    experimentalRules: true
  }
}

Controller Klassen

De volgende klassen breiden de Controller abstracte klasse uit om je in staat te stellen de toegankelijkheidsanalyse van de pagina's van je website handmatig te beheren.

Controller

abstract class Controller

De Controller abstracte klasse bevat de methoden voor het beheren van pagina-analyse. Elke concrete klasse breidt deze klasse uit, zodat de volgende methoden beschikbaar zijn in alle concrete klassen.

analyze

analyze(): Promise<void>

Analyseert de huidige pagina op toegankelijkheidsfouten. Je roept deze methode aan nadat je een webpagina hebt ingesteld voor analyse (bijvoorbeeld waarden in een formulier hebt ingevoerd) en automatische analyse hebt uitgeschakeld met de stop methode of door autoAnalyze op false te zetten.

analyze Retourneert

Promise<void>

analyze Voorbeeld

await controller.analyze()

analyze Equivalent Cypress-opdracht

cy.axeWatcherAnalyze()

flush

flush(): Promise<void>

Stuurt alle resultaten van de toegankelijkheidsscan naar Axe Developer Hub. Moet aan het einde van de testrun worden aangeroepen om te zorgen dat de resultaten naar de servers van Deque's Axe Developer Hub zijn verzonden.

flush Retourneert

Promise<void>

flush Voorbeeld

await controller.flush()

flush Equivalent Cypress-opdracht

cy.axeWatcherFlush()

start

start(): Promise<void>

Hervat de automatische analyse van webpagina's. U roept deze methode aan wanneer u wilt doorgaan met het automatisch analyseren van webpagina's op toegankelijkheidsfouten.

start Retourneert

Promise<void>

start Voorbeeld

await controller.start()

start Equivalent Cypress-opdracht

cy.axeWatcherStart()

stop

stop(): Promise<void>

Stopt de automatische analyse van webpagina's. Nadat je de stop methode hebt aangeroepen, kun je eventuele aanvullende instellingen uitvoeren die je webpagina nodig heeft en vervolgens de analyze methode aanroepen om de pagina op toegankelijkheidsfouten te controleren.

stop Retourneert

Promise<void>

stop Voorbeeld

await controller.stop()

stop Equivalent Cypress-opdracht

cy.axeWatcherStop()

PlaywrightController

De PlaywrightController klasse stelt je in staat om de toegankelijkheidsanalyse handmatig te beheren voor testuitvoeringen met Playwright en Playwright Test. Je kunt automatische toegankelijkheidsanalyse starten en stoppen en pagina's analyseren die extra setup vereisen.

Voor meer informatie over Playwright, zie de Playwright-documentatie.

Constructor

new PlaywrightController(driver: Page): PlaywrightController

Parameters

• driver: Page

De driver waarde is een Playwright Page object.

Retourneert PlaywrightController

PlaywrightController Voorbeeld

import { PlaywrightController, wrapPlaywrightPage } from '@axe-core/watcher/playwright'

let page = await browserContext.newPage()
const controller = new PlaywrightController(page)
page = wrapPlaywrightPage(page, controller)

Zie Controller voor de methoden die zijn geïmplementeerd in de abstracte basis klasse.

PuppeteerController

De PuppeteerController klasse maakt handmatige beheersing van je testuitvoeringen met Puppeteer mogelijk. Handmatige beheersing stelt je in staat om extra setup te bieden die nodig is voor complexere webpagina's.

Voor meer informatie over Puppeteer, zie Puppeteer.

Constructor

new PuppeteerController(driver: Page): PuppeteerController

Parameters

• driver: Page

De driver waarde is een Puppeteer Page object.

Retourneert PuppeteerController

PuppeteerController Voorbeeld

import { PuppeteerController, wrapPuppeteerPage } from '@axe-core/watcher/puppeteer'

let page = await browser.newPage()
const controller = new PuppeteerController(page)
page = wrapPuppeteerPage(page, controller)

Zie Controller voor de methoden die zijn geïmplementeerd in de abstracte basis klasse.

WdioController

De WdioController stelt je in staat om WebdriverIO en WebdriverIO Testrunner testuitvoeringen handmatig te beheren. Voor pagina's die extra setup of configuratie vereisen, kun je automatische tests stopzetten en elke pagina handmatig analyseren die dergelijke setup vereist.

Constructor

new WdioController(driver: Browser): WdioController

Parameters

• driver: Browser

Retourneert WdioController

WdioController Voorbeeld

import { WdioController, wrapWdio } from '@axe-core/watcher/wdio'

// browser is the WebdriverIO Browser instance from your wdioConfig() setup
const controller = new WdioController(browser)
wrapWdio(browser, controller)

Zie Controller voor de methoden die zijn geïmplementeerd in de abstracte basis klasse.

WebdriverController

Constructor

new WebdriverController(driver: WebDriver): WebdriverController

Parameters

• driver: WebDriver

De driver waarde is een Selenium WebDriver object.

Retourneert WebdriverController

WebdriverController Voorbeeld

import { WebdriverController, wrapWebdriver } from '@axe-core/watcher/webdriver'

// browser is the Selenium WebDriver instance from your webdriverConfig() setup
const controller = new WebdriverController(browser)
browser = wrapWebdriver(browser, controller)

Zie Controller voor de methoden die in de abstracte basisklasse zijn geïmplementeerd.

Cypress Aangepaste Commando's

In het Cypress browserautomatiseringsplatform worden de methoden in de *Controller-klassen geïmplementeerd als aangepaste commando's. Zie Aangepaste Commando's op de Cypress-documentatiesite voor meer informatie over het implementeren en gebruiken van aangepaste commando's.

De volgende aangepaste commando's zijn geïmplementeerd. Elk aangepast commando retourneert Chainable<void> om koppeling met andere Cypress commando's mogelijk te maken.

Cypress Commando Voorbeeld

Het volgende voorbeeld laat zien hoe je de Cypress-commando's van de Axe Developer Hub uit het @axe-core/watcher-pakket importeert en vervolgens het axeWatcherFlush-commando aan het einde van elke test aanroept (door het binnen afterEach() te plaatsen):

// Import the axe-watcher commands.
require('@axe-core/watcher/cypress/support')

// Flush Axe-watcher results after each test.
afterEach(() => {
  cy.axeWatcherFlush()
})

Time-out Interface

De timeout object (van het type Timeouts) in de AxeConfiguration-interface stelt gebruikers in staat de time-outwaarden (in milliseconden) te wijzigen voor de respectieve controllerfuncties of de Cypress aangepaste commando's.

interface Timeouts {
  start?: number
  stop?: number
  flush?: number
  analyze?: number
}