testaro 78.0.8 → 78.4.0

package/tests/axe.ts

@@ -0,0 +1,277 @@
+/*
+  © 2021–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 type {Page} from 'playwright';
+import type {AxeResults, NodeResult, RunOptions} from 'axe-core';
+import {getAttributeXPath, getXPathCatalogIndex} from '../procs/xPath';
+import {getStandardResult, addInstance} from '../procs/standard';
+import type {Act, Report, StandardInstance, StandardResult} from '../types';
+const axePlaywright = require('axe-playwright') as typeof import('axe-playwright');
+
+// TYPES
+
+// The axe-act properties this reporter consumes.
+interface AxeAct extends Act {
+  detailLevel?: number;
+  rules?: string[];
+}
+// The impact-classified severity of an axe node.
+type AxeImpact = 'minor' | 'moderate' | 'serious' | 'critical';
+// The native result: rule and node totals and the axe report details.
+interface AxeNativeResult {
+  totals?: {
+    rulesNA: number;
+    rulesPassed: number;
+    rulesWarned: number;
+    rulesViolated: number;
+    warnings: Record<AxeImpact, number>;
+    violations: Record<AxeImpact, number>;
+  };
+  details?: AxeResults;
+}
+// The data of the act report.
+interface AxeData {
+  prevented?: boolean;
+  error?: string;
+}
+
+// CONSTANTS
+
+const {injectAxe} = axePlaywright;
+const severityWeights: Record<AxeImpact, number> = {
+  minor: 0,
+  moderate: 0,
+  serious: 1,
+  critical: 1
+};
+
+/*
+  axe
+  Implements the axe-core ruleset for accessibility.
+
+  The rules argument defaults to all rules; otherwise, specify an array of rule names.
+
+  The detailLevel argument specifies how many result categories are to be included in the
+  details. 0 = none; 1 = violations; 2 = violations and incomplete; 3 = violations, incomplete,
+  and passes; 4 = violations, incomplete, passes, and inapplicable. Regardless of the value of this
+  argument, Axe-core is instructed to report all nodes with violation or incomplete results, but
+  only 1 node per rule found to be passed or inapplicable. Therefore, from the results of this test
+  it is possible to count the rules passed and the inapplicable rules, but not the nodes for which
+  each rule is passed or inapplicable. To count those nodes, one would need to revise the
+  'resultTypes' property of the 'axeOptions' object.
+
+  The report of this test shows rule totals by result category and, within the violation and
+  incomplete categories, node totals by severity. It does not show rule or node totals by test
+  category (“tag”), such as 'wcag21aaa'. Scoring can consider test categories by getting the value
+  of the 'tags' property of each rule.
+  Compiled to axe.js by tsc (issue #73); edit this file, not the emitted one.
+*/
+
+// FUNCTIONS
+
+// Conducts and reports the Axe tests.
+export const reporter = async (page: Page, report: Report, actIndex: number) => {
+  const act = report.acts[actIndex] as AxeAct;
+  const {detailLevel, rules} = act;
+  // Initialize the act report.
+  let data: AxeData = {};
+  const result: {nativeResult: AxeNativeResult; 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 {nativeResult, standardResult} = result;
+  // Inject axe-core into the page.
+  await injectAxe(page as Parameters<typeof injectAxe>[0])
+  .catch(error => {
+    console.log(`ERROR: Axe injection failed (${error.message})`);
+    data.prevented = true;
+    data.error = 'ERROR: axe injection failed';
+  });
+  // If the injection succeeded:
+  if (! data.prevented) {
+    // Get the data on the elements violating the specified axe-core rules.
+    const axeOptions: RunOptions = {
+      resultTypes: ['violations', 'incomplete']
+    };
+    if (rules && rules.length) {
+      // A bare array would be read as tag names; rule IDs need the object form.
+      axeOptions.runOnly = {type: 'rule', values: rules};
+    }
+    else {
+      axeOptions.runOnly = ['experimental', 'best-practice', 'wcag2a', 'wcag2aa', 'wcag2aaa', 'wcag21a', 'wcag21aa', 'wcag21aaa'];
+    }
+    // If the act is scoped to changed subtrees, test only them (axe's include context).
+    const scopeRoots = report.scope?.roots;
+    const context = scopeRoots && scopeRoots.length
+      ? {include: scopeRoots} as unknown as Parameters<typeof axePlaywright.getAxeResults>[1]
+      : null as unknown as undefined;
+    const axeReport = await axePlaywright.getAxeResults(
+      page as Parameters<typeof injectAxe>[0], context, axeOptions
+    );
+    const {inapplicable, passes, incomplete, violations} = axeReport;
+    // If the test succeeded:
+    if (violations) {
+      // Initialize the native result.
+      nativeResult.totals = {
+        rulesNA: 0,
+        rulesPassed: 0,
+        rulesWarned: 0,
+        rulesViolated: 0,
+        warnings: {
+          minor: 0,
+          moderate: 0,
+          serious: 0,
+          critical: 0
+        },
+        violations: {
+          minor: 0,
+          moderate: 0,
+          serious: 0,
+          critical: 0
+        }
+      };
+      nativeResult.details = axeReport;
+      // Populate the native-result totals.
+      const {totals} = nativeResult;
+      totals.rulesNA = inapplicable.length;
+      totals.rulesPassed = passes.length;
+      incomplete.forEach(rule => {
+        totals.rulesWarned++;
+        rule.nodes.forEach(node => {
+          totals.warnings[node.impact as AxeImpact]++;
+        });
+      });
+      violations.forEach(rule => {
+        totals.rulesViolated++;
+        rule.nodes.forEach(node => {
+          totals.violations[node.impact as AxeImpact]++;
+        });
+      });
+      // If standard results are to be reported and there are any suspicions:
+      if (standard && (totals.rulesViolated || totals.rulesWarned)) {
+        // Resolve each suspected element's FULL data-xpath from the live DOM,
+        // keyed by its axe target. axe-core truncates node.html (~300 chars,
+        // appends '...'), so parsing data-xpath out of node.html yields a
+        // truncated XPath for elements with long attribute lists. node.target
+        // is a reliable CSS selector; read the injected data-xpath directly off
+        // the element instead. Falls back to the node.html parse on any failure.
+        const fullXPathByTargetKey: Record<string, string> = {};
+        try {
+          const suspectNodes = (['incomplete', 'violations'] as const)
+          .filter(certainty => nativeResult?.details?.[certainty])
+          .flatMap(certainty => nativeResult.details![certainty].flatMap(rule => rule.nodes));
+          const targets = suspectNodes.map(node => node.target as unknown as string | string[]);
+          const resolvedXPaths = await page.evaluate(targetList => targetList.map(target => {
+            try {
+              // axe target is an array of selectors (nested arrays for frames/
+              // shadow roots). Use the deepest plain-string selector for the
+              // common, non-framed case; skip otherwise.
+              const selector = Array.isArray(target)
+                ? (typeof target[target.length - 1] === 'string' ? target[target.length - 1] : null)
+                : (typeof target === 'string' ? target : null);
+              if (! selector) {
+                return null;
+              }
+              const element = document.querySelector(selector);
+              return element ? element.getAttribute('data-xpath') : null;
+            }
+            catch(error) {
+              return null;
+            }
+          }), targets);
+          suspectNodes.forEach((node, index) => {
+            if (resolvedXPaths[index]) {
+              fullXPathByTargetKey[JSON.stringify(node.target)] = resolvedXPaths[index];
+            }
+          });
+        }
+        catch(error) {
+          // Leave the map empty; every instance falls back to node.html below.
+        }
+        // For each certainty type:
+        (['incomplete', 'violations'] as const).forEach(certainty => {
+          // If there are any suspicions of this type:
+          if (nativeResult?.details?.[certainty]) {
+            // For each rule with any suspicions:
+            nativeResult.details[certainty].forEach(rule => {
+              // For each element suspected of violating the rule:
+              rule.nodes.forEach((node: NodeResult) => {
+                // Get descriptions of the rule.
+                const whatSet = new Set([
+                  rule.help,
+                  ... node.any.map(anyItem => anyItem.message),
+                  ... node.all.map(allItem => allItem.message)
+                ]);
+                // Get the ordinal severity of the suspicion.
+                const ordinalSeverity = severityWeights[node.impact as AxeImpact]
+                + (certainty === 'violations' ? 2 : 0);
+                // Get the XPath of the suspected element from its data-xpath
+                // attribute. Prefer the full value resolved from the live DOM
+                // (above); fall back to parsing it out of axe's node.html,
+                // which axe truncates and can corrupt the XPath.
+                const xPath = fullXPathByTargetKey[JSON.stringify(node.target)]
+                || getAttributeXPath(node.html);
+                addInstance(standardResult, {
+                  ruleID: rule.id,
+                  what: Array.from(whatSet.values()).join('; '),
+                  ordinalSeverity,
+                  outcome: certainty === 'violations' ? 'failed' : 'cantTell',
+                  catalogIndex: getXPathCatalogIndex(report, xPath)
+                });
+              });
+            });
+          }
+        });
+      }
+      // Delete the properties of the report details that the detail level excludes, after the
+      // standard result has been made from them, so the standard result does not depend on
+      // the detail level.
+      const irrelevants = ['inapplicable', 'passes', 'incomplete', 'violations']
+      .slice(0, 4 - (detailLevel as number));
+      irrelevants.forEach(irrelevant => {
+        delete (axeReport as unknown as Record<string, unknown>)[irrelevant];
+      });
+    }
+    // Otherwise, i.e. if the test failed:
+    else {
+      // Report this.
+      data.prevented = true;
+      data.error = 'ERROR: Act failed';
+      if (standard) {
+        standardResult.prevented = true;
+      }
+    }
+  }
+  // Return the result.
+  try {
+    JSON.stringify(data);
+  }
+  catch(error) {
+    const message = `ERROR: Axe result cannot be made JSON (${(error as Error).message})`;
+    console.log(message);
+    data = {
+      prevented: true,
+      error: message
+    };
+  }
+  return {
+    data,
+    result
+  };
+};

package/tests/ed11y.d.ts

@@ -0,0 +1,28 @@
+import type { Page } from 'playwright';
+import type { Report, StandardResult } from '../types';
+interface Ed11yNativeInstance {
+    test: string;
+    content: string;
+    dismissalKey: string;
+    html: string;
+    xPath: string | null | undefined;
+}
+interface Ed11yNativeResult {
+    resultCount?: number;
+    errorCount?: number;
+    warningCount?: number;
+    results?: Ed11yNativeInstance[];
+    prevented?: boolean;
+    error?: string;
+}
+export declare const reporter: (page: Page, report: Report, actIndex: number) => Promise<{
+    data: {
+        prevented?: boolean;
+        error?: string;
+    };
+    result: {
+        nativeResult: Ed11yNativeResult;
+        standardResult: StandardResult;
+    };
+}>;
+export {};

package/tests/ed11y.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
   © 2023–2024 CVS Health and/or one of its affiliates. All rights reserved.
   © 2026 Jeff Witt.
@@ -8,114 +9,155 @@
 
   SPDX-License-Identifier: MIT
 */
-
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reporter = void 0;
+// IMPORTS
+const fs = __importStar(require("fs/promises"));
+const xPath_1 = require("../procs/xPath");
+const standard_1 = require("../procs/standard");
 /*
   ed11y
   Implements the Editoria11y ruleset for accessibility.
+  Compiled to ed11y.js by tsc (issue #73); edit this file, not the emitted one.
 */
-
-// IMPORTS
-
-const fs = require('fs/promises');
-const {getXPathCatalogIndex} = require('../procs/xPath');
-
 // FUNCTIONS
-
 // Performs and reports the Editoria11y tests.
-exports.reporter = async (page, report, actIndex) => {
-  // Get the nonce, if any.
-  const act = report.acts[actIndex];
-  const {jobData} = report;
-  const scriptNonce = jobData && jobData.lastScriptNonce;
-  // Initialize the act report.
-  let data = {};
-  const result = {
-    nativeResult: {},
-    standardResult: {}
-  };
-  const standard = report.standard !== 'no';
-  // If standard results are to be reported:
-  if (standard) {
-    // Initialize the standard result.
-    result.standardResult = {
-      prevented: false,
-      totals: [0, 0, 0, 0],
-      instances: []
+const reporter = async (page, report, actIndex) => {
+    // Get the nonce, if any.
+    const act = report.acts[actIndex];
+    const { jobData } = report;
+    const scriptNonce = (jobData && jobData.lastScriptNonce);
+    // Initialize the act report.
+    let data = {};
+    const result = {
+        nativeResult: {},
+        standardResult: {}
     };
-  }
-  // Get the tool script.
-  const script = await fs.readFile(`${__dirname}/../ed11y/editoria11y.min.js`, 'utf8');
-  // Perform the specified tests and populate the native result.
-  result.nativeResult = await page.evaluate(args => new Promise(async resolve => {
-    const {scriptNonce, script, rulesToTest} = args;
-    // When the script has been executed, creating data in an Ed11y object:
-    document.addEventListener('ed11yResults', async () => {
-      let {results} = Ed11y;
-      // If rules were selected:
-      if (rulesToTest) {
-        // Remove results of other rules.
-        results = results.filter(result => rulesToTest.includes(result.test));
-      }
-      // Return the native result.
-      resolve({
-        resultCount: results.length,
-        errorCount: Ed11y.errorCount,
-        warningCount: Ed11y.warningCount,
-        results: results.map(result => ({
-          test: result.test,
-          content: result.content.replace(/\s+/g, ' ').trim(),
-          dismissalKey: result.dismissalKey,
-          html: result.element.outerHTML.slice(0, 500),
-          xPath: window.getXPath(result.element)
-        }))
-      });
+    const standard = report.standard !== 'no';
+    // If standard results are to be reported:
+    if (standard) {
+        // Initialize the standard result.
+        result.standardResult = (0, standard_1.getStandardResult)();
+    }
+    // Get the tool script.
+    const script = await fs.readFile(`${__dirname}/../ed11y/editoria11y.min.js`, 'utf8');
+    // Perform the specified tests and populate the native result.
+    result.nativeResult = await page.evaluate(args => new Promise(async (resolve) => {
+        const { scriptNonce, script, rulesToTest } = args;
+        // When the script has been executed, creating data in an Ed11y object:
+        document.addEventListener('ed11yResults', async () => {
+            let { results } = Ed11y;
+            // If rules were selected:
+            if (rulesToTest) {
+                // Remove results of other rules.
+                results = results.filter(result => rulesToTest.includes(result.test));
+            }
+            // Return the native result.
+            resolve({
+                resultCount: results.length,
+                errorCount: Ed11y.errorCount,
+                warningCount: Ed11y.warningCount,
+                results: results.map(result => ({
+                    test: result.test,
+                    content: result.content.replace(/\s+/g, ' ').trim(),
+                    dismissalKey: result.dismissalKey,
+                    html: result.element.outerHTML.slice(0, 500),
+                    xPath: window.getXPath(result.element)
+                }))
+            });
+        });
+        // Add the tool script to the page.
+        const toolScript = document.createElement('script');
+        if (scriptNonce) {
+            toolScript.nonce = scriptNonce;
+            console.log(`Added nonce ${scriptNonce} to tool script`);
+        }
+        toolScript.textContent = script;
+        document.body.insertAdjacentElement('beforeend', toolScript);
+        // Execute the tool script, creating Ed11y and triggering the event listener.
+        try {
+            await new Ed11y({
+                alertMode: 'headless'
+            });
+        }
+        catch (error) {
+            resolve({
+                prevented: true,
+                error: error.message
+            });
+        }
+        ;
+    }), {
+        scriptNonce,
+        script,
+        rulesToTest: act.rules
     });
-    // Add the tool script to the page.
-    const toolScript = document.createElement('script');
-    if (scriptNonce) {
-      toolScript.nonce = scriptNonce;
-      console.log(`Added nonce ${scriptNonce} to tool script`);
+    // If the tool script failed to run:
+    if (result.nativeResult.prevented) {
+        // Report the prevention.
+        data.prevented = true;
+        data.error = result.nativeResult.error;
+        if (standard) {
+            result.standardResult.prevented = true;
+        }
     }
-    toolScript.textContent = script;
-    document.body.insertAdjacentElement('beforeend', toolScript);
-    // Execute the tool script, creating Ed11y and triggering the event listener.
-    try {
-      await new Ed11y({
-        alertMode: 'headless'
-      });
+    // Otherwise, i.e. if it ran, and if a standard result is to be reported:
+    else if (standard) {
+        const { standardResult } = result;
+        const { warningCount, errorCount, results } = result.nativeResult;
+        // Populate the standard-result totals.
+        standardResult.totals = [warningCount, 0, errorCount, 0];
+        // For each native-result instance:
+        results.forEach(nativeInstance => {
+            // Create a standard-result instance.
+            const { test, content, dismissalKey, xPath } = nativeInstance;
+            // A dismissable warning is a manual check.
+            (0, standard_1.pushInstance)(standardResult, {
+                ruleID: test,
+                what: content,
+                ordinalSeverity: dismissalKey ? 0 : 2,
+                outcome: dismissalKey ? 'cantTell' : 'failed',
+                uncertainty: dismissalKey ? 'judgement-required' : undefined,
+                catalogIndex: (0, xPath_1.getXPathCatalogIndex)(report, xPath)
+            });
+        });
     }
-    catch(error) {
-      resolve({
-        prevented: true,
-        error: error.message
-      });
+    return {
+        data,
+        result
     };
-  }), {
-    scriptNonce,
-    script,
-    rulesToTest: act.rules
-  });
-  // If a standard result is to be reported:
-  if (standard) {
-    const {standardResult} = result;
-    const {warningCount, errorCount, results} = result.nativeResult;
-    // Populate the standard-result totals.
-    standardResult.totals = [warningCount, 0, errorCount, 0];
-    // For each native-result instance:
-    results.forEach(nativeInstance => {
-      // Create a standard-result instance.
-      const {test, content, dismissalKey, xPath} = nativeInstance;
-      const instance = {};
-      instance.ruleID = test;
-      instance.what = content;
-      instance.ordinalSeverity = dismissalKey ? 0 : 2;
-      instance.count = 1;
-      instance.catalogIndex = getXPathCatalogIndex(report, xPath);
-      standardResult.instances.push(instance);
-    });
-  }
-  return {
-    data,
-    result
-  };
 };
+exports.reporter = reporter;