testaro 78.0.8 → 78.6.0

package/tests/aslint.ts

@@ -0,0 +1,301 @@
+/*
+  © 2023–2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2026 Jeff Witt.
+  © 2025–2026 Jonathan Robert Pool.
+
+  Licensed under the MIT License. See LICENSE file at the project root or
+  https://opensource.org/license/mit/ for details.
+
+  SPDX-License-Identifier: MIT
+*/
+
+// IMPORTS
+
+import * as fs from 'fs/promises';
+import type {Page} from 'playwright';
+// Shared configuration for timeout multiplier.
+import {applyMultiplier} from '../procs/config';
+import {getNormalizedXPath, getXPathCatalogIndex} from '../procs/xPath';
+import {getStandardResult, addInstance} from '../procs/standard';
+import type {Act, Report, StandardResult} from '../types';
+
+// TYPES
+
+// The aslint-act properties this reporter consumes.
+interface AslintAct extends Act {
+  rules?: string[];
+}
+// One violation of a rule in an ASLint result.
+interface AslintResultItem {
+  message?: {actual?: {description?: string}};
+  element?: {xpath?: string};
+}
+// The report of one rule in an ASLint result.
+interface AslintRuleData {
+  issueType: string;
+  status: {type: string};
+  results: AslintResultItem[];
+}
+// The native result: the parsed ASLint report.
+interface AslintNativeResult {
+  rules?: Record<string, AslintRuleData>;
+}
+
+// CONSTANTS
+
+/*
+  Differentiates some rule IDs of aslint.
+  If the purported rule ID is a key and the what property contains all of the strings except the
+  last of any array item of the value of that key, then the final rule ID is the last item of that
+  array item.
+*/
+const aslintData: Record<string, string[][]> = {
+  'misused_required_attribute': [
+    ['not needed', 'misused_required_attributeR']
+  ],
+  'accessible_svg': [
+    ['associated', 'accessible_svgI'],
+    ['tabindex', 'accessible_svgT']
+  ],
+  'audio_alternative': [
+    ['track', 'audio_alternativeT'],
+    ['alternative', 'audio_alternativeA'],
+    ['bgsound', 'audio_alternativeB']
+  ],
+  'table_missing_description': [
+    ['describedby', 'associated', 'table_missing_descriptionDM'],
+    ['labeledby', 'associated', 'table_missing_descriptionLM'],
+    ['caption', 'not been defined', 'table_missing_descriptionC'],
+    ['summary', 'empty', 'table_missing_descriptionS'],
+    ['describedby', 'empty', 'table_missing_descriptionDE'],
+    ['labeledby', 'empty', 'table_missing_descriptionLE'],
+    ['caption', 'no content', 'table_missing_descriptionE']
+  ],
+  'label_implicitly_associated': [
+    ['only whice spaces', 'label_implicitly_associatedW'],
+    ['more than one', 'label_implicitly_associatedM']
+  ],
+  'label_inappropriate_association': [
+    ['Missing', 'label_inappropriate_associationM'],
+    ['non-form', 'label_inappropriate_associationN']
+  ],
+  'table_row_and_column_headers': [
+    ['headers', 'table_row_and_column_headersRC'],
+    ['Content', 'table_row_and_column_headersB'],
+    ['head of the columns', 'table_row_and_column_headersH']
+  ],
+  'color_contrast_state_pseudo_classes_abstract': [
+    ['position: fixed', 'color_contrast_state_pseudo_classes_abstractF'],
+    ['transparent', 'color_contrast_state_pseudo_classes_abstractB'],
+    ['least 3:1', 'color_contrast_state_pseudo_classes_abstract3'],
+    ['least 4.5:1', 'color_contrast_state_pseudo_classes_abstract4']
+  ],
+  'color_contrast_state_pseudo_classes_active': [
+    ['position: fixed', 'color_contrast_state_pseudo_classes_abstractF'],
+    ['transparent', 'color_contrast_state_pseudo_classes_abstractB'],
+    ['least 3:1', 'color_contrast_state_pseudo_classes_abstract3'],
+    ['least 4.5:1', 'color_contrast_state_pseudo_classes_abstract4']
+  ],
+  'color_contrast_state_pseudo_classes_focus': [
+    ['position: fixed', 'color_contrast_state_pseudo_classes_abstractF'],
+    ['transparent', 'color_contrast_state_pseudo_classes_abstractB'],
+    ['least 3:1', 'color_contrast_state_pseudo_classes_abstract3'],
+    ['least 4.5:1', 'color_contrast_state_pseudo_classes_abstract4']
+  ],
+  'color_contrast_state_pseudo_classes_hover': [
+    ['position: fixed', 'color_contrast_state_pseudo_classes_abstractF'],
+    ['transparent', 'color_contrast_state_pseudo_classes_abstractB'],
+    ['least 3:1', 'color_contrast_state_pseudo_classes_abstract3'],
+    ['least 4.5:1', 'color_contrast_state_pseudo_classes_abstract4']
+  ],
+  'color_contrast_aaa': [
+    ['transparent', 'color_contrast_aaaB'],
+    ['least 4.5:1', 'color_contrast_aaa4'],
+    ['least 7:1', 'color_contrast_aaa7']
+  ],
+  'animation': [
+    ['duration', 'animationD'],
+    ['iteration', 'animationI'],
+    ['mechanism', 'animationM']
+  ],
+  'page_title': [
+    ['empty', 'page_titleN'],
+    ['not identify', 'page_titleU']
+  ],
+  'aria_labelledby_association': [
+    ['exist', 'aria_labelledby_associationN'],
+    ['empty', 'aria_labelledby_associationE']
+  ],
+  'html_lang_attr': [
+    ['parameters', 'html_lang_attrP'],
+    ['nothing', 'html_lang_attrN'],
+    ['empty', 'html_lang_attrE']
+  ],
+  'missing_label': [
+    ['associated', 'missing_labelI'],
+    ['defined', 'missing_labelN'],
+    ['multiple labels', 'missing_labelM']
+  ],
+  'orientation': [
+    ['loaded', 'orientationT']
+  ]
+};
+
+/*
+  aslint
+  Implements the ASLint ruleset for accessibility.
+  Compiled to aslint.js by tsc (issue #73); edit this file, not the emitted one.
+*/
+
+// FUNCTIONS
+
+// Conducts and reports the ASLint tests.
+export const reporter = async (page: Page, report: Report, actIndex: number) => {
+  // Initialize the act report.
+  let data: {prevented?: boolean; error?: string} = {};
+  const result: {nativeResult: AslintNativeResult; standardResult: StandardResult} = {
+    nativeResult: {},
+    standardResult: {}
+  };
+  const standard = report.standard !== 'no';
+  // If standard results are to be reported:
+  if (standard) {
+    // Initialize the standard result.
+    result.standardResult = getStandardResult();
+  }
+  const {standardResult} = result;
+  // Get the ASLint runner and bundle scripts.
+  const aslintRunner = await fs.readFile(`${__dirname}/../procs/aslint.js`, 'utf8');
+  const aslintBundlePath = require.resolve('aslint-testaro/aslint.bundle.js');
+  const aslintBundle = await fs.readFile(aslintBundlePath, 'utf8');
+  // Get the nonce, if any.
+  const act = report.acts[actIndex] as AslintAct;
+  const {jobData} = report;
+  const scriptNonce = (jobData && jobData.lastScriptNonce) as string | undefined;
+  // Inject the ASLint bundle and runner into the head of the page.
+  await page.evaluate(args => {
+    const {scriptNonce, aslintBundle, aslintRunner} = args;
+    // Bundle.
+    const bundleEl = document.createElement('script');
+    bundleEl.id = 'aslintBundle';
+    if (scriptNonce) {
+      bundleEl.nonce = scriptNonce;
+      console.log(`Added nonce ${scriptNonce} to bundle`);
+    }
+    bundleEl.textContent = aslintBundle;
+    document.head.insertAdjacentElement('beforeend', bundleEl);
+    // Runner.
+    const runnerEl = document.createElement('script');
+    if (scriptNonce) {
+      runnerEl.nonce = scriptNonce;
+      console.log(`Added nonce ${scriptNonce} to runner`);
+    }
+    runnerEl.textContent = aslintRunner;
+    document.body.insertAdjacentElement('beforeend', runnerEl);
+  }, {scriptNonce, aslintBundle, aslintRunner})
+  .catch(error => {
+    const message = `ERROR: ASLint injection failed (${error.message.slice(0, 400)})`;
+    console.log(message);
+    data.prevented = true;
+    data.error = message;
+    if (standard) {
+      standardResult.prevented = true;
+    }
+  });
+  const reportLoc = page.locator('#aslintResult');
+  // If the injection succeeded:
+  if (! data.prevented) {
+    try {
+      // Wait for the test results to be attached to the page.
+      const waitOptions = {
+        state: 'attached' as const,
+        timeout: applyMultiplier(20000)
+      };
+      await reportLoc.waitFor(waitOptions);
+    }
+    catch(error) {
+      const message = 'Attachment of test results to page failed';
+      console.log(message);
+      data.prevented = true;
+      data.error = `${message} (${(error as Error).message})`;
+    };
+  }
+  // If the injection and the result attachment both succeeded:
+  if (! data.prevented) {
+    // Get their text.
+    const actReport = await reportLoc.textContent();
+    try {
+      const nativeResult = result.nativeResult = JSON.parse(actReport as string);
+      // If any rules were reported violated:
+      if (nativeResult.rules) {
+        const {rules} = nativeResult as Required<AslintNativeResult>;
+        // For each such rule:
+        for (const ruleID of Object.keys(rules)) {
+          const ruleData = rules[ruleID];
+          const {issueType, status} = ruleData;
+          const excluded = act.rules && ! act.rules.includes(ruleID);
+          const {type} = status;
+          // If rule is not an error or warning or is not to be tested:
+          if (
+            excluded
+            || ['passed', 'skipped'].includes(type)
+            || ! ['error', 'warning'].includes(issueType)
+          ) {
+            // Delete the rule report.
+            delete rules[ruleID];
+          }
+        }
+        // If standard results are to be reported:
+        if (standard) {
+          const ruleIDs = Object.keys(rules);
+          // For each violated rule:
+          for (let ruleID of ruleIDs) {
+            const ruleData = rules[ruleID];
+            const {issueType, results} = ruleData;
+            // For each violation:
+            for (const result of results) {
+              const {message, element} = result;
+              // Get a description of the violated rule.
+              const what = message?.actual?.description ?? '';
+              const changer = aslintData[ruleID]?.find(
+                specs => specs.slice(0, -1).every(matcher => what.includes(matcher))
+              );
+              // If the rule ID is differentiatable:
+              if (changer) {
+                // Differentiate it.
+                ruleID = changer[changer.length - 1];
+              }
+              // Get the ordinal severity of the violation.
+              const ordinalSeverity = issueType === 'warning' ? 1 : 2;
+              // Get the pathID of the element.
+              const {xpath} = element!;
+              const pathID = getNormalizedXPath(xpath);
+              // Use it to get the index of the element in the catalog.
+              const catalogIndex = getXPathCatalogIndex(report, pathID);
+              // Add an instance to the standard result.
+              addInstance(standardResult, {
+                ruleID,
+                what,
+                ordinalSeverity,
+                outcome: issueType === 'warning' ? 'cantTell' : 'failed',
+                catalogIndex
+              });
+            }
+          }
+        }
+      }
+    }
+    // If the results are not JSON:
+    catch(error) {
+      const message = `Result processing failed (${(error as Error).message})`;
+      console.log(`ERROR: ${message}`);
+      // Report this.
+      data.prevented = true;
+      data.error = message;
+    }
+  }
+  return {
+    data,
+    result
+  };
+};

package/tests/axe.d.ts

@@ -0,0 +1,27 @@
+import type { Page } from 'playwright';
+import type { AxeResults } from 'axe-core';
+import type { Report, StandardResult } from '../types';
+type AxeImpact = 'minor' | 'moderate' | 'serious' | 'critical';
+interface AxeNativeResult {
+    totals?: {
+        rulesNA: number;
+        rulesPassed: number;
+        rulesWarned: number;
+        rulesViolated: number;
+        warnings: Record<AxeImpact, number>;
+        violations: Record<AxeImpact, number>;
+    };
+    details?: AxeResults;
+}
+interface AxeData {
+    prevented?: boolean;
+    error?: string;
+}
+export declare const reporter: (page: Page, report: Report, actIndex: number) => Promise<{
+    data: AxeData;
+    result: {
+        nativeResult: AxeNativeResult;
+        standardResult: StandardResult;
+    };
+}>;
+export {};