testaro 78.0.6 → 78.4.0

package/tests/htmlcs.ts

@@ -0,0 +1,181 @@
+/*
+  © 2022–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';
+import {getAttributeXPath, getXPathCatalogIndex} from '../procs/xPath';
+import {getStandardResult, pushInstance} from '../procs/standard';
+import type {Act, Report, StandardInstance, StandardResult} from '../types';
+
+// TYPES
+
+// The htmlcs-act properties this reporter consumes.
+interface HtmlcsAct extends Act {
+  rules?: string[];
+}
+// The native result: violation totals and the parts of error and warning messages.
+interface HtmlcsNativeResult {
+  totals: {
+    failed: number;
+    cantTell: number;
+  };
+  error: string[][];
+  warning: string[][];
+}
+
+/*
+  htmlcs
+  Implements the HTML CodeSniffer ruleset.
+  Compiled to htmlcs.js by tsc (issue #73); edit this file, not the emitted one.
+*/
+
+// FUNCTIONS
+
+// Conducts and reports the HTML CodeSniffer tests.
+export const reporter = async (page: Page, report: Report, actIndex: number) => {
+  const act = report.acts[actIndex] as HtmlcsAct;
+  const {rules} = act;
+  // Initialize the act report.
+  const data: {prevented?: boolean; error?: string} = {};
+  const result: {nativeResult: HtmlcsNativeResult; standardResult: StandardResult} = {
+    nativeResult: {
+      totals: {
+        failed: 0,
+        cantTell: 0
+      },
+      error: [],
+      warning: []
+    },
+    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;
+  // Get the HTMLCS script.
+  const scriptText = await fs.readFile(`${__dirname}/../htmlcs/HTMLCS.js`, 'utf8');
+  const scriptNonce = (report.jobData && report.jobData.lastScriptNonce) as string | undefined;
+  let messageStrings: string[] = [];
+  // For each class of standards to  be tested for:
+  for (const actStandard of ['WCAG2AAA']) {
+    const nextViolations = await page.evaluate(args => {
+      const actStandard = args[0] as string;
+      const rules = args[1] as string[] | undefined;
+      const scriptText = args[2] as string;
+      const scriptNonce = args[3] as string;
+      const script = document.createElement('script');
+      script.nonce = scriptNonce;
+      script.textContent = scriptText;
+      // HTMLCS.js is a UMD bundle. If the page exposes an AMD loader (define.amd, e.g. Wix or RequireJS) or leaked CommonJS globals (exports, module), the UMD wrapper registers HTMLCS as a module and never attaches HTMLCS_RUNNER to window, so the run() call below throws and the tool is reported prevented. Hide those loader globals for the duration of the synchronous script execution, so the wrapper falls through to its browser-global branch.
+      const umdDefine = window.define;
+      const umdExports = window.exports;
+      const umdModule = window.module;
+      window.define = undefined;
+      window.exports = undefined;
+      // The cast erases; window.module otherwise types as Node's module global.
+      window.module = undefined as unknown as typeof window.module;
+      // Add the HTMLCS script to the page.
+      document.head.insertAdjacentElement('beforeend', script);
+      // Restore the loader globals.
+      window.define = umdDefine;
+      window.exports = umdExports;
+      window.module = umdModule;
+      // If only some rules are to be employed:
+      if (rules && Array.isArray(rules) && rules.length) {
+        // Redefine WCAG 2 AAA as including only them.
+        if (! window.HTMLCS_WCAG2AAA) {
+          window.HTMLCS_WCAG2AAA = {};
+        }
+        window.HTMLCS_WCAG2AAA.sniffs = rules;
+      }
+      let violations: string[] | null = null;
+      // Run the tests.
+      try {
+        violations = window.HTMLCS_RUNNER!.run(actStandard);
+      }
+      catch(error) {
+        console.log(`ERROR executing HTMLCS_RUNNER on ${document.URL} (${(error as Error).message})`);
+      }
+      // Return the reported violations of that standard.
+      return violations;
+    }, [actStandard, rules, scriptText, scriptNonce]);
+    // If all reported violations of the standard are validly described:
+    if (nextViolations?.every(violation => typeof violation === 'string')) {
+      // Add their descriptions to the violation descriptions.
+      messageStrings.push(... nextViolations);
+    }
+    // Otherwise, i.e. if any reported violations are invalidly described:
+    else {
+      // Report this.
+      data.prevented = true;
+      data.error = 'ERROR executing HTMLCS_RUNNER in the page';
+      break;
+    }
+  }
+  // If no error was thrown:
+  if (! data.prevented) {
+    // Sort the violations by class and standard.
+    messageStrings.sort();
+    // Remove any duplicate violations.
+    messageStrings = [... new Set(messageStrings)];
+    // For each violation:
+    for (const string of messageStrings) {
+      // Split its message into severity class, rule ID, tagname, ID, rule description, and excerpt.
+      const parts = string.split(/\|/, 6);
+      const partCount = parts.length;
+      // If the message partitions are too few:
+      if (partCount < 6) {
+        // Report this.
+        console.log(`ERROR: Violation string ${string} has too few parts`);
+      }
+      // Otherwise, if the message reports an error:
+      else if (parts[0] === 'Error') {
+        // Add the rest of its message to the native-result errors.
+        nativeResult.error.push(parts.slice(1));
+        // Increment the error total.
+        nativeResult.totals.failed++;
+      }
+      // Otherwise, if the message reports a warning:
+      else if (parts[0] === 'Warning') {
+        // Add the rest of its message to the native-result warnings.
+        nativeResult.warning.push(parts.slice(1));
+        // Increment the warning total.
+        nativeResult.totals.cantTell++;
+      }
+      // If standard results are to be reported and the message reports an error or warning:
+      if (standard && ['Error', 'Warning'].includes(parts[0])) {
+        const xPath = getAttributeXPath(parts[5]);
+        pushInstance(standardResult, {
+          ruleID: `${parts[0][0]}-${parts[1]}`,
+          what: parts[4],
+          ordinalSeverity: parts[0] === 'Warning' ? 0 : 2,
+          outcome: parts[0] === 'Warning' ? 'cantTell' : 'failed',
+          catalogIndex: getXPathCatalogIndex(report, xPath)
+        });
+      }
+    }
+    // If standard results are to be reported:
+    if (standard) {
+      // Populate the standard-result totals.
+      standardResult.totals![0] = nativeResult.totals.cantTell;
+      standardResult.totals![2] = nativeResult.totals.failed;
+    }
+  }
+  return {
+    data,
+    result
+  };
+};

package/tests/ibm.d.ts

@@ -0,0 +1,52 @@
+import type { Page } from 'playwright';
+import type { Report, StandardResult } from '../types';
+interface IbmItem {
+    ruleId: string;
+    level: string;
+    message: string;
+    snippet: string;
+    apiArgs?: unknown;
+    category?: unknown;
+    ignored?: unknown;
+    messageArgs?: unknown;
+    reasonId?: unknown;
+    ruleTime?: unknown;
+    value?: unknown;
+}
+interface IbmCounts {
+    violation: number;
+    recommendation: number;
+    [key: string]: number;
+}
+interface IbmActReport {
+    summary?: {
+        counts?: IbmCounts;
+    };
+    results: IbmItem[];
+    items?: IbmItem[];
+}
+type IbmTrimmedReport = {
+    totals: IbmCounts;
+    items: IbmItem[] | undefined;
+    error?: undefined;
+} | {
+    totals: null;
+    items: IbmItem[];
+    error: string;
+};
+export declare const reporter: (page: Page, report: Report, actIndex: number) => Promise<{
+    data: {};
+    result: {
+        nativeResult: IbmTrimmedReport | Record<string, never>;
+        standardResult: StandardResult;
+    };
+} | {
+    data: {
+        report: IbmActReport;
+    } | {
+        prevented: boolean;
+        error: string;
+    };
+    result: {};
+}>;
+export {};

package/tests/ibm.js

@@ -1,5 +1,7 @@
+"use strict";
 /*
   © 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
@@ -7,7 +9,12 @@
 
   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 accessibilityChecker = require('accessibility-checker');
+const { getCompliance } = accessibilityChecker;
 /*
   ibm
   Implements the IBM Equal Access ruleset for accessibility.
@@ -16,192 +23,184 @@
 
   This rule engine is compatible with Windows only if the accessibility-checker package
   is revised. See README.md for details.
+  Compiled to ibm.js by tsc (issue #73); edit this file, not the emitted one.
 */
-
-// IMPORTS
-
-const {getAttributeXPath, getXPathCatalogIndex} = require('../procs/xPath');
-const accessibilityChecker = require('accessibility-checker');
-const {getCompliance} = accessibilityChecker;
-
 // FUNCTIONS
-
 // Runs the IBM test and returns the result.
-const run = async content => {
-  const nowLabel = (new Date()).toISOString().slice(0, 19);
-  try {
-    const ibmReport = await getCompliance(content, nowLabel);
-    if (typeof ibmReport === 'object' && ibmReport.report) {
-      return ibmReport;
+const run = async (content) => {
+    const nowLabel = (new Date()).toISOString().slice(0, 19);
+    try {
+        const ibmReport = await getCompliance(content, nowLabel);
+        if (typeof ibmReport === 'object' && ibmReport.report) {
+            return ibmReport;
+        }
+        else {
+            return {
+                prevented: true,
+                error: 'ibm getCompliance produced no report'
+            };
+        }
     }
-    else {
-      return {
-        prevented: true,
-        error: 'ibm getCompliance produced no report'
-      };
+    catch (error) {
+        console.log('ibm getCompliance failed');
+        return {
+            prevented: true,
+            error: error.message.slice(0, 200)
+        };
     }
-  }
-  catch(error) {
-    console.log('ibm getCompliance failed');
-    return {
-      prevented: true,
-      error: error.message.slice(0, 200)
-    };
-  }
 };
 // Revises act-report totals for any rule limitation.
 const limitRuleTotals = (actReport, rules) => {
-  if (rules && Array.isArray(rules) && rules.length) {
-    const totals = actReport.summary.counts;
-    const items = actReport.results;
-    totals.violation = totals.recommendation = 0;
-    items.forEach(item => {
-      if (rules.includes(item.ruleId)) {
-        totals[item.level]++;
-      }
-    });
-  }
+    if (rules && Array.isArray(rules) && rules.length) {
+        const totals = actReport.summary.counts;
+        const items = actReport.results;
+        totals.violation = totals.recommendation = 0;
+        items.forEach(item => {
+            if (rules.includes(item.ruleId)) {
+                totals[item.level]++;
+            }
+        });
+    }
 };
 // Trims an IBM report.
 const trimActReport = (actReport, withItems, rules) => {
-  // If the act report includes a summary:
-  if (actReport && actReport.summary) {
-    // Remove excluded rules from the act report.
-    limitRuleTotals(actReport, rules);
-    const totals = actReport.summary.counts;
-    // If the act report includes totals:
-    if (totals) {
-      // If itemization is required:
-      if (withItems) {
-        // Trim the items.
-        if (rules && Array.isArray(rules) && rules.length) {
-          actReport.items = actReport.results.filter(item => rules.includes(item.ruleId));
+    // If the act report includes a summary:
+    if (actReport && actReport.summary) {
+        // Remove excluded rules from the act report.
+        limitRuleTotals(actReport, rules);
+        const totals = actReport.summary.counts;
+        // If the act report includes totals:
+        if (totals) {
+            // If itemization is required:
+            if (withItems) {
+                // Trim the items.
+                if (rules && Array.isArray(rules) && rules.length) {
+                    actReport.items = actReport.results.filter(item => rules.includes(item.ruleId));
+                }
+                else {
+                    actReport.items = actReport.results;
+                }
+                actReport.items.forEach(item => {
+                    delete item.apiArgs;
+                    delete item.category;
+                    delete item.ignored;
+                    delete item.messageArgs;
+                    delete item.reasonId;
+                    delete item.ruleTime;
+                    delete item.value;
+                });
+            }
+            // Return the act report, trimmed.
+            return {
+                totals,
+                items: actReport.items
+            };
         }
+        // Otherwise, i.e. if it excludes totals:
         else {
-          actReport.items = actReport.results;
+            // Return an act report with this error.
+            return {
+                totals: null,
+                items: [],
+                error: 'No totals reported'
+            };
         }
-        actReport.items.forEach(item => {
-          delete item.apiArgs;
-          delete item.category;
-          delete item.ignored;
-          delete item.messageArgs;
-          delete item.reasonId;
-          delete item.ruleTime;
-          delete item.value;
-        });
-      }
-      // Return the act report, trimmed.
-      return {
-        totals,
-        items: actReport.items
-      };
     }
-    // Otherwise, i.e. if it excludes totals:
+    // Otherwise, i.e. if it excludes a summary:
     else {
-      // Return an act report with this error.
-      return {
-        totals: null,
-        items: [],
-        error: 'No totals reported'
-      };
+        // Return an act report with this error.
+        return {
+            totals: null,
+            items: [],
+            error: 'No summary reported'
+        };
     }
-  }
-  // Otherwise, i.e. if it excludes a summary:
-  else {
-    // Return an act report with this error.
-    return {
-      totals: null,
-      items: [],
-      error: 'No summary reported'
-    };
-  }
 };
 // Conducts and reports the IBM Equal Access tests.
-exports.reporter = async (page, report, actIndex) => {
-  const act = report.acts[actIndex];
-  const {withItems, rules} = act;
-  // Initialize the act report.
-  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 { withItems, rules } = act;
+    // Initialize the act report.
+    const result = {
+        nativeResult: {},
+        standardResult: {}
     };
-  }
-  try {
-    // Conduct the tests.
-    const runReport = await run(page);
-    const actReport = runReport.report;
-    // If there were results:
-    if (actReport) {
-      // Trim them.
-      result.nativeResult = trimActReport(actReport, withItems, rules);
-      const {nativeResult, standardResult} = result;
-      const {error, totals} = nativeResult;
-      // If they were not trimmable:
-      if (error) {
-        // Return an act report with this error.
-        return {
-          data: {
-            prevented: true,
-            error
-          },
-          result: {}
+    const standard = report.standard !== 'no';
+    // If standard results are to be reported:
+    if (standard) {
+        // Initialize the standard result.
+        result.standardResult = (0, standard_1.getStandardResult)();
+    }
+    try {
+        // Conduct the tests.
+        const runReport = await run(page);
+        const actReport = runReport.report;
+        // If there were results:
+        if (actReport) {
+            // Trim them.
+            result.nativeResult = trimActReport(actReport, withItems, rules);
+            const { nativeResult, standardResult } = result;
+            const { error, totals } = nativeResult;
+            // If they were not trimmable:
+            if (error) {
+                // Return an act report with this error.
+                return {
+                    data: {
+                        prevented: true,
+                        error
+                    },
+                    result: {}
+                };
+            }
+            // Otherwise, i.e. if they were trimmable, and if standard results are to be reported:
+            if (standard) {
+                // Populate the totals of the standard result.
+                standardResult.totals = [totals.recommendation, 0, totals.violation, 0];
+                // For each item of the native result (without itemization, items is
+                // undefined and this throws, caught below; verbatim from the original):
+                nativeResult.items.forEach(item => {
+                    // Populate a standard instance. Potential violations, potential recommendations, and
+                    // manual checks are engine-flagged uncertainty.
+                    const standardItem = {
+                        ruleID: item.ruleId,
+                        what: item.message,
+                        ordinalSeverity: item.level === 'recommendation' ? 0 : 2,
+                        outcome: ['violation', 'recommendation'].includes(item.level) ? 'failed' : 'cantTell'
+                    };
+                    // Get the XPath from the added attribute, because path.dom is wrong.
+                    const xPath = (0, xPath_1.getAttributeXPath)(item.snippet);
+                    // If the XPath was obtained:
+                    if (xPath) {
+                        // Add the catalog index to the standard instance.
+                        standardItem.catalogIndex = (0, xPath_1.getXPathCatalogIndex)(report, xPath);
+                    }
+                    // Add the standard instance to the standard result.
+                    (0, standard_1.pushInstance)(standardResult, standardItem);
+                });
+            }
+            return {
+                data: {},
+                result
+            };
         }
-      }
-      // Otherwise, i.e. if they were trimmable, and if standard results are to be reported:
-      if (standard) {
-        // Populate the totals of the standard result.
-        standardResult.totals = [totals.recommendation, 0, totals.violation, 0];
-        // For each item of the native result:
-        nativeResult.items.forEach(item => {
-          // Populate a standard instance.
-          const standardItem = {
-            ruleID: item.ruleId,
-            what: item.message,
-            ordinalSeverity: item.level === 'recommendation' ? 0 : 2,
-            count: 1
-          };
-          // Get the XPath from the added attribute, because path.dom is wrong.
-          const xPath = getAttributeXPath(item.snippet);
-          // If the XPath was obtained:
-          if (xPath) {
-            // Add the catalog index to the standard instance.
-            standardItem.catalogIndex = getXPathCatalogIndex(report, xPath);
-          }
-          // Add the standard instance to the standard result.
-          standardResult.instances.push(standardItem);
-        });
-      }
-      return {
-        data: {},
-        result
-      };
+        // Otherwise, i.e. if there was only an error, return it in an act report.
+        return {
+            data: runReport,
+            result: {}
+        };
     }
-    // Otherwise, i.e. if there was only an error, return it in an act report.
-    return {
-      data: runReport,
-      result: {}
+    // If an error occurred:
+    catch (error) {
+        const message = `Act failed (${error.message.slice(0, 200)})`;
+        console.log(message);
+        // Return it in an act report.
+        return {
+            data: {
+                prevented: true,
+                error: message
+            },
+            result: {}
+        };
     }
-  }
-  // If an error occurred:
-  catch(error) {
-    const message = `Act failed (${error.message.slice(0, 200)})`;
-    console.log(message);
-    // Return it in an act report.
-    return {
-      data: {
-        prevented: true,
-        error: message
-      },
-      result: {}
-    };
-  }
 };
+exports.reporter = reporter;