testaro 13.0.2 → 14.1.0

package/actSpecs.js

@@ -122,7 +122,7 @@ exports.actSpecs = {
       }
     ],
     test: [
-      'Perform a test',
+      'Perform test of a tool',
       {
         which: [true, 'string', 'isTest', 'test name'],
         what: [false, 'string', 'hasLength', 'comment']
@@ -154,95 +154,26 @@ exports.actSpecs = {
   },
   tests: {
     alfa: [
-      'Perform an alfa test',
+      'Perform alfa tests',
       {
         rules: [false, 'array', 'areStrings', 'rule names (e.g., r25), if not all']
       }
     ],
-    attVal: [
-      'Perform an attVal test',
-      {
-        attributeName: [true, 'string', 'hasLength', 'name of attribute'],
-        areLicit: [true, 'boolean', '', 'whether values are licit'],
-        values: [true, 'array', 'areStrings', 'values of attribute'],
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    autocomplete: [
-      'Perform an autocomplete test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
     axe: [
-      'Perform an Axe test',
+      'Perform Axe tests',
       {
         detailLevel: [true, 'number', '', '0 = least, 4 = most'],
         rules: [true, 'array', 'areStrings', 'rule names, or empty if all']
       }
     ],
     continuum: [
-      'Perform a continuum test',
+      'Perform Continuum tests',
       {
         rules: [false, 'array', 'areNumbers', 'rule numbers (e.g., 25), if not all']
       }
     ],
-    dupAtt: [
-      'Perform a dupAtt test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    elements: [
-      'Perform an elements test',
-      {
-        detailLevel: [true, 'number', '', '0 to 3, to specify the level of detail'],
-        tagName: [false, 'string', 'hasLength', 'tag name (upper-case) of elements'],
-        onlyVisible: [false, 'boolean', '', 'whether to exclude invisible elements'],
-        attribute: [false, 'string', 'hasLength', 'required attribute selector']
-      }
-    ],
-    embAc: [
-      'Perform an embAc test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    filter: [
-      'Perform a filter test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    focInd: [
-      'Perform a focInd test',
-      {
-        revealAll: [true, 'boolean', '', 'whether to make all elements visible first'],
-        allowedDelay: [true, 'number', '', 'milliseconds to wait for an outline'],
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    focOp: [
-      'Perform a focOp test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    focVis: [
-      'Perform a focVis test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    hover: [
-      'Perform a hover test',
-      {
-        sampleSize: [false, 'number', '', 'limit on sample size of triggers, if any'],
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
     htmlcs: [
-      'Perform an htmlcs test',
+      'Perform HTML CodeSniffer tests',
       {
         rules: [
           false,
@@ -253,61 +184,17 @@ exports.actSpecs = {
       }
     ],
     ibm: [
-      'Perform an IBM Equal Access test',
+      'Perform IBM Equal Access tests',
       {
         withItems: [true, 'boolean', '', 'itemize'],
         withNewContent: [
-          false, 'boolean', '', 'true: use a URL; false: use page content; omitted: both'
+          true, 'boolean', '', 'true: use a URL; false: use page content'
         ],
         rules: [false, 'array', 'areStrings', 'rule names (e.g., RPT_Elem_UniqueId), if not all']
       }
     ],
-    labClash: [
-      'Perform a labClash test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    linkTo: [
-      'Perform a linkTo test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    linkUl: [
-      'Perform a linkUl test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    menuNav: [
-      'Perform a menuNav test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    miniText: [
-      'Perform a miniText test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    motion: [
-      'Perform a motion test',
-      {
-        delay: [true, 'number', '', 'ms to wait before first screen shot'],
-        interval: [true, 'number', '', 'ms between screen shots'],
-        count: [true, 'number', '', 'count of screen shots to make']
-      }
-    ],
-    nonTable: [
-      'Perform a nonTable test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
     nuVal: [
-      'Perform a nuVal test',
+      'Perform Nu Html Checker tests',
       {
         messages: [
           false,
@@ -318,60 +205,32 @@ exports.actSpecs = {
       }
     ],
     qualWeb: [
-      'Perform a qualWeb test',
+      'Perform QualWeb tests',
       {
         withNewContent: [true, 'boolean', '', 'whether to use a URL instead of page content'],
         rules: [false, 'array', 'areStrings', 'QualWeb or ACT IDs of ACT rules to include, if not all']
       }
     ],
-    radioSet: [
-      'Perform a radioSet test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    styleDiff: [
-      'Perform a styleDiff test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
-    tabNav: [
-      'Perform a tabNav test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
-    ],
     tenon: [
-      'Perform a Tenon test',
+      'Perform Tenon tests',
       {
+        tenonData: [true, 'object', '', 'object with accessToken and requestIDs properties'],
         id: [true, 'string', 'hasLength', 'ID of the requested test instance']
       }
     ],
-    textNodes: [
-      'Perform a textNodes test',
+    testaro: [
+      'Perform Testaro tests',
       {
-        detailLevel: [true, 'number', '', '0 to 3, to specify the level of detail'],
-        text: [false, 'string', 'hasLength', 'case-insensitive substring of the text node']
-      }
-    ],
-    titledEl: [
-      'Perform a titledEl test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
+        withItems: [true, 'boolean', '', 'itemize'],
+        rules: [false, 'array', 'areStrings', 'IDs of rules to include if array starts with y or exclude if with n, if not all evaluative rules'],
+        args: [false, 'object', '', 'extra args (object with rule properties and arrays of argument values as values ({focInd: [false, 250], hover: [-1], motion: [2500, 2500, 5]} by default'],
       }
     ],
     wave: [
-      'Perform a WebAIM WAVE test',
+      'Perform WAVE tests',
       {
         reportType: [true, 'number', '', 'WAVE report type']
       }
-    ],
-    zIndex: [
-      'Perform a zIndex test',
-      {
-        withItems: [true, 'boolean', '', 'itemize']
-      }
     ]
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "13.0.2",
+  "version": "14.1.0",
   "description": "Automation of accessibility testing",
   "main": "index.js",
   "scripts": {

package/run.js

@@ -9,6 +9,8 @@
 require('dotenv').config();
 // Requirements for acts.
 const {actSpecs} = require('./actSpecs');
+// Module to standardize report formats.
+const {standardize} = require('./standardize');
 // Playwright package.
 const playwright = require('playwright');
 
@@ -27,48 +29,23 @@ const moves = {
   radio: 'input[type=radio]',
   search: 'input[type=search], input[aria-label*=search i], input[placeholder*=search i]',
   select: 'select',
-  text: 'input[type=text], input:not([type])'
+  text: 'input'
 };
 // Names and descriptions of tests.
 const tests = {
   alfa: 'alfa',
-  allHidden: 'page that is entirely or mostly hidden',
-  attVal: 'elements with attributes having illicit values',
-  autocomplete: 'name and email inputs without autocomplete attributes',
   axe: 'Axe',
-  bulk: 'count of visible elements',
   continuum: 'Level Access Continuum, community edition',
-  docType: 'document without a doctype property',
-  dupAtt: 'elements with duplicate attributes',
   elements: 'data on specified elements',
-  embAc: 'active elements embedded in links or buttons',
-  filter: 'filter styles on elements',
-  focAll: 'focusable and Tab-focused elements',
-  focInd: 'focus indicators',
-  focOp: 'focusability and operability',
-  focVis: 'links that are invisible when focused',
-  hover: 'hover-caused content changes',
   htmlcs: 'HTML CodeSniffer WCAG 2.1 AA ruleset',
   ibm: 'IBM Accessibility Checker',
-  labClash: 'labeling inconsistencies',
-  linkTo: 'links without destinations',
-  linkUl: 'adjacent-link underlining',
-  menuNav: 'keyboard navigation between focusable menu items',
-  miniText: 'text smaller than 11 pixels',
-  motion: 'motion',
-  nonTable: 'table elements used for layout',
   nuVal: 'Nu Html Checker',
   qualWeb: 'QualWeb',
-  radioSet: 'fieldset grouping of radio buttons',
-  role: 'roles',
-  styleDiff: 'style inconsistencies',
-  tabNav: 'keyboard navigation between tab elements',
   tenon: 'Tenon',
+  testaro: 'Testaro',
   textNodes: 'data on specified text nodes',
   title: 'page title',
-  titledEl: 'title attributes on inappropriate elements',
   wave: 'WAVE',
-  zIndex: 'z indexes'
 };
 // Browser types available in PlayWright.
 const browserTypeNames = {
@@ -144,6 +121,9 @@ const hasType = (variable, type) => {
   else if (type === 'number') {
     return typeof variable === 'number';
   }
+  else if (type === 'object') {
+    return typeof variable === 'object' && ! Array.isArray(variable);
+  }
   else {
     return false;
   }
@@ -325,8 +305,8 @@ const launch = async (report, typeName, lowMotion = false) => {
     // Launch a browser of that type.
     const browserOptions = {
       logger: {
-        isEnabled: (name, severity) => false,
-        log: (name, severity, message, args) => console.log(message.slice(0, 100))
+        isEnabled: () => false,
+        log: (name, severity, message) => console.log(message.slice(0, 100))
       }
     };
     if (debug) {
@@ -538,6 +518,10 @@ const isTrue = (object, specs) => {
     else if (relation === '!i') {
       satisfied = typeof actual === 'string' && ! actual.includes(criterion);
     }
+    else if (relation === 'e') {
+      satisfied = typeof actual === 'object'
+      && JSON.stringify(actual) === JSON.stringify(criterion);
+    }
     return [actual, satisfied];
   }
   // Otherwise, i.e. if the specifications are invalid:
@@ -708,7 +692,7 @@ const doActs = async (report, actIndex, page) => {
           requestedURL = resolved;
           const {strict} = report;
           // Visit it and wait until the DOM is loaded.
-          response = await goTo(report, page, requestedURL, 15000, 'domcontentloaded', strict);
+          let response = await goTo(report, page, requestedURL, 15000, 'domcontentloaded', strict);
           // If the visit fails:
           if (response.error) {
             // Launch another browser type.
@@ -1014,7 +998,7 @@ const doActs = async (report, actIndex, page) => {
                 let failureCount = 0;
                 // For each expectation:
                 expectations.forEach(spec => {
-                  const truth = isTrue(testReport.result, spec);
+                  const truth = isTrue(testReport, spec);
                   testReport.result.expectations.push({
                     property: spec[0],
                     relation: spec[1],
@@ -1034,6 +1018,22 @@ const doActs = async (report, actIndex, page) => {
               // Add the result object (possibly an array) to the act.
               const resultCount = Object.keys(testReport.result).length;
               act.result = resultCount ? testReport.result : {success: false};
+              // If a standard-format result is to be included in the report:
+              const standard = process.env.STANDARD;
+              if (['also', 'only'].includes(standard)) {
+                // Initialize it.
+                act.standardResult = {
+                  totals: [],
+                  instances: []
+                };
+                // Populate it.
+                standardize(act);
+                // If the original-format result is not to be included in the report:
+                if (standard === 'only') {
+                  // Remove it.
+                  delete act.result;
+                }
+              }
             }
             // Otherwise, if the act is a move:
             else if (moves[act.type]) {