testaro 78.0.8 → 78.6.0

package/tests/axe.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
   © 2021–2024 CVS Health and/or one of its affiliates. All rights reserved.
   © 2026 Jeff Witt.
@@ -8,7 +9,19 @@
 
   SPDX-License-Identifier: MIT
 */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reporter = void 0;
+const xPath_1 = require("../procs/xPath");
+const standard_1 = require("../procs/standard");
+const axePlaywright = require('axe-playwright');
+// CONSTANTS
+const { injectAxe } = axePlaywright;
+const severityWeights = {
+    minor: 0,
+    moderate: 0,
+    serious: 1,
+    critical: 1
+};
 /*
   axe
   Implements the axe-core ruleset for accessibility.
@@ -28,215 +41,201 @@
   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.
 */
-
-// IMPORTS
-
-const axePlaywright = require('axe-playwright');
-const {getAttributeXPath, getXPathCatalogIndex} = require('../procs/xPath');
-
-// CONSTANTS
-
-const {injectAxe} = axePlaywright;
-const severityWeights = {
-  minor: 0,
-  moderate: 0,
-  serious: 1,
-  critical: 1
-};
-
 // FUNCTIONS
-
 // Conducts and reports the Axe tests.
-exports.reporter = async (page, report, actIndex) => {
-  const act = report.acts[actIndex];
-  const {detailLevel, rules} = act;
-  // 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) => {
+    const act = report.acts[actIndex];
+    const { detailLevel, rules } = act;
+    // Initialize the act report.
+    let data = {};
+    const result = {
+        nativeResult: {},
+        standardResult: {}
     };
-  }
-  const {nativeResult, standardResult} = result;
-  // Inject axe-core into the page.
-  await injectAxe(page)
-  .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 = {
-      resultTypes: ['violations', 'incomplete']
-    };
-    if (rules && rules.length) {
-      axeOptions.runOnly = rules;
-    }
-    else {
-      axeOptions.runOnly = ['experimental', 'best-practice', 'wcag2a', 'wcag2aa', 'wcag2aaa', 'wcag21a', 'wcag21aa', 'wcag21aaa'];
+    const standard = report.standard !== 'no';
+    // If standard results are to be reported:
+    if (standard) {
+        // Initialize the standard result.
+        result.standardResult = (0, standard_1.getStandardResult)();
     }
-    const axeReport = await axePlaywright.getAxeResults(page, null, 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
+    const { nativeResult, standardResult } = result;
+    // Inject axe-core into the page.
+    await injectAxe(page)
+        .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 = {
+            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 };
         }
-      };
-      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]++;
-        });
-      });
-      violations.forEach(rule => {
-        totals.rulesViolated++;
-        rule.nodes.forEach(node => {
-          totals.violations[node.impact]++;
-        });
-      });
-      // Delete irrelevant properties from the report details.
-      const irrelevants = ['inapplicable', 'passes', 'incomplete', 'violations']
-      .slice(0, 4 - detailLevel);
-      irrelevants.forEach(irrelevant => {
-        delete axeReport[irrelevant];
-      });
-      // 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 = {};
-        try {
-          const suspectNodes = ['incomplete', 'violations']
-          .filter(certainty => nativeResult?.details?.[certainty])
-          .flatMap(certainty => nativeResult.details[certainty].flatMap(rule => rule.nodes));
-          const targets = suspectNodes.map(node => node.target);
-          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];
+        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 }
+            : null;
+        const axeReport = await axePlaywright.getAxeResults(page, 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]++;
+                });
+            });
+            violations.forEach(rule => {
+                totals.rulesViolated++;
+                rule.nodes.forEach(node => {
+                    totals.violations[node.impact]++;
+                });
+            });
+            // 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 = {};
+                try {
+                    const suspectNodes = ['incomplete', 'violations']
+                        .filter(certainty => nativeResult?.details?.[certainty])
+                        .flatMap(certainty => nativeResult.details[certainty].flatMap(rule => rule.nodes));
+                    const targets = suspectNodes.map(node => node.target);
+                    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'].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) => {
+                                // 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]
+                                    + (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)]
+                                    || (0, xPath_1.getAttributeXPath)(node.html);
+                                (0, standard_1.addInstance)(standardResult, {
+                                    ruleID: rule.id,
+                                    what: Array.from(whatSet.values()).join('; '),
+                                    ordinalSeverity,
+                                    outcome: certainty === 'violations' ? 'failed' : 'cantTell',
+                                    catalogIndex: (0, xPath_1.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);
+            irrelevants.forEach(irrelevant => {
+                delete axeReport[irrelevant];
+            });
         }
-        catch(error) {
-          // Leave the map empty; every instance falls back to node.html below.
+        // Otherwise, i.e. if the test failed:
+        else {
+            // Report this.
+            data.prevented = true;
+            data.error = 'ERROR: Act failed';
+            if (standard) {
+                standardResult.prevented = true;
+            }
         }
-        // For each certainty type:
-        ['incomplete', 'violations'].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 => {
-                // 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]
-                + (certainty === 'violations' ? 2 : 0);
-                // Increment the standard total.
-                standardResult.totals[ordinalSeverity]++;
-                // 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);
-                const instance = {
-                  ruleID: rule.id,
-                  what: Array.from(whatSet.values()).join('; '),
-                  ordinalSeverity,
-                  count: 1,
-                  catalogIndex: getXPathCatalogIndex(report, xPath)
-                };
-                standardResult.instances.push(instance);
-              });
-            });
-          }
-        });
-      }
     }
-    // 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.message})`;
+        console.log(message);
+        data = {
+            prevented: true,
+            error: message
+        };
     }
-  }
-  // Return the result.
-  try {
-    JSON.stringify(data);
-  }
-  catch(error) {
-    const message = `ERROR: Axe result cannot be made JSON (${error.message})`;
-    console.log(message);
-    data = {
-      prevented: true,
-      error: message
+    return {
+        data,
+        result
     };
-  }
-  return {
-    data,
-    result
-  };
 };
+exports.reporter = reporter;