testaro 78.0.8 → 78.6.0

package/tests/ibm.ts

@@ -0,0 +1,287 @@
+/*
+  © 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 {getAttributeXPath, getXPathCatalogIndex} from '../procs/xPath';
+import {getStandardResult, pushInstance} from '../procs/standard';
+import type {Act, Report, StandardInstance, StandardResult} from '../types';
+const accessibilityChecker = require('accessibility-checker') as typeof import('accessibility-checker');
+const {getCompliance, getConfig} = accessibilityChecker;
+
+// TYPES
+
+// The ibm-act properties this reporter consumes.
+interface IbmAct extends Act {
+  withItems?: boolean;
+  rules?: string[];
+}
+// One item (rule violation) of an IBM act report.
+interface IbmItem {
+  ruleId: string;
+  level: string;
+  message: string;
+  snippet: string;
+  apiArgs?: unknown;
+  category?: unknown;
+  ignored?: unknown;
+  messageArgs?: unknown;
+  reasonId?: unknown;
+  ruleTime?: unknown;
+  value?: unknown;
+}
+// The violation totals of an IBM act report.
+interface IbmCounts {
+  violation: number;
+  recommendation: number;
+  [key: string]: number;
+}
+// An IBM act report before trimming.
+interface IbmActReport {
+  summary?: {counts?: IbmCounts};
+  results: IbmItem[];
+  items?: IbmItem[];
+}
+// An IBM act report after trimming: results, or an error.
+type IbmTrimmedReport =
+  | {totals: IbmCounts; items: IbmItem[] | undefined; error?: undefined}
+  | {totals: null; items: IbmItem[]; error: string};
+
+/*
+  ibm
+  Implements the IBM Equal Access ruleset for accessibility.
+
+  This rule engine depends on aceconfig.js.
+
+  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.
+*/
+
+// FUNCTIONS
+
+/*
+  Which IBM rule engine runs, per the IBM_ENGINE environment variable:
+    archive (default): the rule archive IBM deploys ("latest"), which is what
+      users of IBM's own tools get. It can lag the npm package (engine 4.0.27
+      under accessibility-checker 4.0.33 in September 2026).
+    package: the engine released with the installed accessibility-checker,
+      the one IBM's published ACT report describes. It is fetched from the
+      same CDN as the archive's.
+  accessibility-checker reads aceconfig.js from the working directory and then
+  ignores a configuration passed to it, so the package engine is selected by
+  adjusting its processed configuration before the first test. Setting
+  ruleArchiveVersion also keeps the two engines' cached files apart and makes
+  getConfig report the engine actually used.
+*/
+export type IbmEngineMode = 'archive' | 'package';
+let engineSelection: Promise<{mode: IbmEngineMode; version: string | null}> | null = null;
+export const ibmEngine = () => {
+  engineSelection ??= (async () => {
+    const requested = (process.env.IBM_ENGINE || 'archive').trim().toLowerCase();
+    if (! ['archive', 'package'].includes(requested)) {
+      console.log(`WARNING: IBM_ENGINE=${process.env.IBM_ENGINE} is not archive or package; using archive`);
+    }
+    const mode: IbmEngineMode = requested === 'package' ? 'package' : 'archive';
+    const config = await getConfig() as unknown as {
+      toolVersion?: string; rulePack?: string; ruleArchiveVersion?: string; ruleArchiveLabel?: string;
+    };
+    if (mode === 'package' && config.toolVersion) {
+      config.rulePack = `https://cdn.jsdelivr.net/npm/accessibility-checker-engine@${config.toolVersion}`;
+      config.ruleArchiveVersion = config.toolVersion;
+      config.ruleArchiveLabel = `accessibility-checker-engine ${config.toolVersion} (package)`;
+    }
+    return {mode, version: config.ruleArchiveVersion ?? null};
+  })();
+  return engineSelection;
+};
+// Runs the IBM test and returns the result.
+const run = async (content: Page) => {
+  const nowLabel = (new Date()).toISOString().slice(0, 19);
+  try {
+    await ibmEngine();
+    const ibmReport = await getCompliance(content, nowLabel);
+    if (typeof ibmReport === 'object' && ibmReport.report) {
+      return ibmReport as unknown as {report: IbmActReport};
+    }
+    else {
+      return {
+        prevented: true,
+        error: 'ibm getCompliance produced no report'
+      };
+    }
+  }
+  catch(error) {
+    console.log('ibm getCompliance failed');
+    return {
+      prevented: true,
+      error: (error as Error).message.slice(0, 200)
+    };
+  }
+};
+// Revises act-report totals for any rule limitation.
+const limitRuleTotals = (actReport: IbmActReport, rules: string[] | undefined) => {
+  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: IbmActReport | undefined, withItems: boolean | undefined, rules: string[] | undefined
+): IbmTrimmedReport => {
+  // 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 {
+      // Return an act report with this error.
+      return {
+        totals: null,
+        items: [],
+        error: 'No totals 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.
+export const reporter = async (page: Page, report: Report, actIndex: number) => {
+  const act = report.acts[actIndex] as IbmAct;
+  const {withItems, rules} = act;
+  // Initialize the act report.
+  const result: {nativeResult: IbmTrimmedReport | Record<string, never>; 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();
+  }
+  try {
+    // Conduct the tests.
+    const runReport = await run(page);
+    const actReport = (runReport as {report?: IbmActReport}).report;
+    // If there were results:
+    if (actReport) {
+      // Trim them.
+      result.nativeResult = trimActReport(actReport, withItems, rules);
+      const {nativeResult, standardResult} = result as
+        {nativeResult: IbmTrimmedReport; standardResult: StandardResult};
+      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: StandardInstance = {
+            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 = 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.
+          pushInstance(standardResult, standardItem);
+        });
+      }
+      return {
+        data: {},
+        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 as Error).message.slice(0, 200)})`;
+    console.log(message);
+    // Return it in an act report.
+    return {
+      data: {
+        prevented: true,
+        error: message
+      },
+      result: {}
+    };
+  }
+};

package/tests/nuVal.d.ts

@@ -0,0 +1,13 @@
+import type { Page } from 'playwright';
+import type { NuResult } from '../procs/nu';
+import type { Report, StandardResult } from '../types';
+export declare const reporter: (page: Page, report: Report, actIndex: number) => Promise<{
+    data: {
+        prevented?: boolean;
+        error?: string;
+    };
+    result: {
+        nativeResult: NuResult;
+        standardResult: StandardResult;
+    };
+}>;

package/tests/nuVal.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
   © 2022–2024 CVS Health and/or one of its affiliates. All rights reserved.
   © 2026 Jeff Witt.
@@ -8,131 +9,125 @@
 
   SPDX-License-Identifier: MIT
 */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reporter = void 0;
+const nu_1 = require("../procs/nu");
+const xPath_1 = require("../procs/xPath");
+const standard_1 = require("../procs/standard");
 /*
   nuVal
   Subjects a page and its source to the Nu Html Checker, thereby testing scripted content found only in the loaded page and erroneous content before the browser corrects it. The API erratically replaces left and right double quotation marks with invalid UTF-8, which appears as 2 or 3 successive instances of the replacement character (U+fffd). Therefore, this test removes all such quotation marks and the replacement character. That causes 'Bad value “” for' to become 'Bad value  for'. Since the corruption of quotation marks is erratic, no better solution is known.
   This rule engine is the API version of the Nu Html Checker. It is an alternative to the nuVnu rule engine, which uses the same validator as an installed dependency. Each rule engine has advantages and disadvantages. The main advantage of nuVal is that it does not require the Testaro host to provide a Java virtual machine. The main advantage of the nuVnu tool is that it can evaluate pages reachable from the host that Testaro runs on even if not reachable from the public Internet.
   This rule engine calls the W3C validation service unless a TESTARO_NU_URL environment variable is defined with the URL of another instance of the API.
+  Compiled to nuVal.js by tsc (issue #73); edit this file, not the emitted one.
 */
-
-// IMPORTS
-
-const {curate, getContent, getExtractExcerpt} = require('../procs/nu');
-const {getAttributeXPath, getXPathCatalogIndex} = require('../procs/xPath');
-
 // FUNCTIONS
-
 // Conducts and reports the Nu Html Checker API tests.
-exports.reporter = async (page, report, actIndex) => {
-  const act = report.acts[actIndex];
-  const {rules, withSource} = act;
-  // Initialize the act report.
-  const 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 {standardResult} = result;
-  // Get the content.
-  const content = await getContent(page, withSource);
-  const {testTarget} = content;
-  // If it was obtained and contains a test target:
-  if (testTarget) {
-    const fetchOptions = {
-      method: 'post',
-      headers: {
-        'user-agent': 'Mozilla/5.0',
-        'content-type': 'text/html; charset=utf-8'
-      },
-      body: testTarget
-    };
-    // Override target for self-hosted Nu Html Checker instances (Docker
-    // image ghcr.io/validator/validator or equivalent). Defaults to the
-    // public W3C service, which 502s on bodies >~80 kB.
-    const nuURL = process.env.TESTARO_NU_URL
-      || 'https://validator.w3.org/nu/?parser=html&out=json';
-    let nuData = {};
-    let nuResponse = new Response();
-    try {
-      // Get a Nu Html Checker report from the W3C validator service.
-      nuResponse = await fetch(nuURL, fetchOptions);
-      const {ok, status, statusText} = nuResponse;
-      // If the acquisition succeeded:
-      if (ok) {
-        // Get the response body as an object.
-        nuData = await nuResponse.json();
-      }
-      // Otherwise, i.e. if the request failed:
-      else {
-        // Get the response body as text.
-        const nuResponseText = await nuResponse.text();
-        // Add a failure report to the data.
-        data.prevented = true;
-        data.error = `HTTP ${status}: ${statusText} (${nuResponseText?.slice(0, 200)})`;
-      }
-    }
-    // If an error occurred:
-    catch (error) {
-      // Report it.
-      const message = `ERROR getting results (${error.message}; status ${nuResponse.status || 'none'} (${JSON.stringify(nuData?.body || 'no body', null, 2)})`;
-      console.log(message);
-      data.prevented = true;
-      data.error = message;
+const reporter = async (page, report, actIndex) => {
+    const act = report.acts[actIndex];
+    const { rules, withSource } = act;
+    // Initialize the act report.
+    const data = {};
+    const result = {
+        nativeResult: {},
+        standardResult: {}
     };
-    // Postprocess the response data and add the postprocessed data to the native result.
-    result.nativeResult = await curate(data, nuData, rules);
+    const standard = report.standard !== 'no';
     // If standard results are to be reported:
     if (standard) {
-      // For each message in the native result:
-      result.nativeResult.messages.forEach(message => {
-        const ordinalSeverity = message.type === 'info' ? 0 : 3;
-        // Increment the applicable standard-result total.
-        standardResult.totals[ordinalSeverity]++;
-        // Initialize a standard instance.
-        const standardInstance = {
-          ruleID: message.message,
-          what: message.message,
-          ordinalSeverity,
-          count: 1,
+        // Initialize the standard result.
+        result.standardResult = (0, standard_1.getStandardResult)();
+    }
+    const { standardResult } = result;
+    // Get the content.
+    const content = await (0, nu_1.getContent)(page, withSource);
+    const { testTarget } = content;
+    // If it was obtained and contains a test target:
+    if (testTarget) {
+        const fetchOptions = {
+            method: 'post',
+            headers: {
+                'user-agent': 'Mozilla/5.0',
+                'content-type': 'text/html; charset=utf-8'
+            },
+            body: testTarget
         };
-        // Get the XPath of the element from its extract.
-        const xPath = getAttributeXPath(message.extract);
-        // If the acquisition succeeded:
-        if (xPath) {
-          // Add the catalog index to the standard instance.
-          standardInstance.catalogIndex = getXPathCatalogIndex(report, xPath);
+        // Override target for self-hosted Nu Html Checker instances (Docker
+        // image ghcr.io/validator/validator or equivalent). Defaults to the
+        // public W3C service, which 502s on bodies >~80 kB.
+        const nuURL = process.env.TESTARO_NU_URL
+            || 'https://validator.w3.org/nu/?parser=html&out=json';
+        let nuData = {};
+        let nuResponse = new Response();
+        try {
+            // Get a Nu Html Checker report from the W3C validator service.
+            nuResponse = await fetch(nuURL, fetchOptions);
+            const { ok, status, statusText } = nuResponse;
+            // If the acquisition succeeded:
+            if (ok) {
+                // Get the response body as an object.
+                nuData = await nuResponse.json();
+            }
+            // Otherwise, i.e. if the request failed:
+            else {
+                // Get the response body as text.
+                const nuResponseText = await nuResponse.text();
+                // Add a failure report to the data.
+                data.prevented = true;
+                data.error = `HTTP ${status}: ${statusText} (${nuResponseText?.slice(0, 200)})`;
+            }
+        }
+        // If an error occurred:
+        catch (error) {
+            // Report it.
+            const message = `ERROR getting results (${error.message}; status ${nuResponse.status || 'none'} (${JSON.stringify(nuData?.body || 'no body', null, 2)})`;
+            console.log(message);
+            data.prevented = true;
+            data.error = message;
         }
-        // Get an excerpt of the extract, if the extract identifies no element.
-        const extractExcerpt = getExtractExcerpt(message.extract);
-        // If one was obtained (e.g. the erroneous CSS of a CSS: Parse Error message):
-        if (extractExcerpt) {
-          // Add it to the description of the violation, so the extract is not lost.
-          standardInstance.what = `${message.message} Extract: ${extractExcerpt}`;
+        ;
+        // Postprocess the response data and add the postprocessed data to the native result.
+        result.nativeResult = await (0, nu_1.curate)(data, nuData, rules);
+        // If standard results are to be reported:
+        if (standard) {
+            // For each message in the native result:
+            result.nativeResult.messages.forEach(message => {
+                const isInfo = message.type === 'info';
+                // Initialize a standard instance. Informational messages are uncertainty.
+                const standardInstance = {
+                    ruleID: message.message,
+                    what: message.message,
+                    ordinalSeverity: isInfo ? 0 : 3,
+                    outcome: isInfo ? 'cantTell' : 'failed'
+                };
+                // Get the XPath of the element from its extract.
+                const xPath = (0, xPath_1.getAttributeXPath)(message.extract);
+                // If the acquisition succeeded:
+                if (xPath) {
+                    // Add the catalog index to the standard instance.
+                    standardInstance.catalogIndex = (0, xPath_1.getXPathCatalogIndex)(report, xPath);
+                }
+                // Get an excerpt of the extract, if the extract identifies no element.
+                const extractExcerpt = (0, nu_1.getExtractExcerpt)(message.extract);
+                // If one was obtained (e.g. the erroneous CSS of a CSS: Parse Error message):
+                if (extractExcerpt) {
+                    // Add it to the description of the violation, so the extract is not lost.
+                    standardInstance.what = `${message.message} Extract: ${extractExcerpt}`;
+                }
+                // Add the standard instance to the standard result.
+                (0, standard_1.addInstance)(standardResult, standardInstance);
+            });
         }
-        // Add the standard instance to the standard result.
-        standardResult.instances.push(standardInstance);
-      })
     }
-  }
-  // Otherwise, i.e. if the page content was not obtained:
-  else {
-    // Report this.
-    data.prevented = true;
-    data.error = 'Content not obtained';
-  }
-  return {
-    data,
-    result
-  };
+    // Otherwise, i.e. if the page content was not obtained:
+    else {
+        // Report this.
+        data.prevented = true;
+        data.error = 'Content not obtained';
+    }
+    return {
+        data,
+        result
+    };
 };
+exports.reporter = reporter;