testaro 13.0.2 → 14.1.0

package/standardize.js

@@ -0,0 +1,338 @@
+/*
+  standardize.js
+  Converts test results to the standard format.
+*/
+
+// ########## FUNCTIONS
+
+// Limits the length of and unilinearizes a string.
+const cap = rawString => {
+  const string = rawString.replace(/\s+/g, ' ');
+  if (string && string.length > 400) {
+    return `${string.slice(0, 200)} ... ${string.slice(-200)}`;
+  }
+  else if (string) {
+    return string;
+  }
+  else {
+    return '';
+  }
+};
+// Converts issue instances at an axe certainty level.
+const doAxe = (result, standardResult, certainty) => {
+  if (result.details && result.details[certainty]) {
+    result.details[certainty].forEach(rule => {
+      rule.nodes.forEach(node => {
+        const whatSet = new Set([
+          rule.help,
+          ... node.any.map(anyItem => anyItem.message),
+          ... node.all.map(allItem => allItem.message)
+        ]);
+        const initialSeverity = ['minor', 'moderate', 'serious', 'critical'].indexOf(node.impact);
+        const moreSeverity = certainty === 'violations' ? 4 : 0;
+        const instance = {
+          issueID: rule.id,
+          what: Array.from(whatSet.values()).join('; '), 
+          ordinalSeverity: initialSeverity + moreSeverity,
+          location: {
+            doc: 'dom',
+            type: 'selector',
+            spec: node.target && node.target.length ? node.target[0] : ''
+          },
+          excerpt: cap(node.html)
+        };
+        standardResult.instances.push(instance);
+      });
+    });
+  }
+};
+// Converts issue instances at an htmlcs severity level.
+const doHTMLCS = (result, standardResult, severity) => {
+  if (result[severity]) {
+    Object.keys(result[severity]).forEach(ruleID => {
+      const ruleData = result[severity][ruleID];
+      Object.keys(ruleData).forEach(what => {
+        ruleData[what].forEach(item => {
+          const {tagName, code} = item;
+          const instance = {
+            issueID: ruleID,
+            what,
+            ordinalSeverity: ['Warning', 'Error'].indexOf(severity),
+            location: {
+              doc: 'dom',
+              type: '',
+              spec: ''
+            },
+            excerpt: cap(`${tagName ? tagName + ': ' : ''}${code || ''}`)
+          };
+          standardResult.instances.push(instance);
+        });
+      });
+    });
+  }
+};
+// Converts issue instances from a nuVal document type.
+const doNuVal = (result, standardResult, docType) => {
+  const items = result[docType] && result[docType].messages;
+  if (items && items.length) {
+    items.forEach(item => {
+      const instance = {
+        issueID: item.message,
+        what: item.message,
+        ordinalSeverity: -1,
+        location: {
+          doc: docType === 'pageContent' ? 'dom' : 'source',
+          type: 'line',
+          spec: item.lastLine.toString()
+        },
+        excerpt: cap(item.extract)
+      };
+      const {type, subType} = item;
+      if (type === 'info' && subType === 'warning') {
+        instance.ordinalSeverity = 0;
+      }
+      else if (type === 'error') {
+        instance.ordinalSeverity = subType === 'fatal' ? 2 : 1;
+      }
+      standardResult.instances.push(instance);
+    });
+  }
+};
+// Converts instances of a qualWeb rule class.
+const doQualWeb = (result, standardResult, ruleClassName) => {
+  if (result.modules && result.modules[ruleClassName]) {
+    const ruleClass = result.modules[ruleClassName];
+    let classSeverity = 0;
+    if (ruleClass.metadata) {
+      classSeverity = 2 * [
+        'best-practices', 'wcag-techniques', 'act-rules'
+      ].indexOf(ruleClassName);
+      standardResult.totals[classSeverity] += ruleClass.metadata.warning;
+      standardResult.totals[classSeverity + 1] += ruleClass.metadata.failed;
+    }
+    Object.keys(ruleClass.assertions).forEach(rule => {
+      ruleClass.assertions[rule].results.forEach(item => {
+        item.elements.forEach(element => {
+          const instance = {
+            issueID: ruleClass.assertions[rule].name,
+            what: ruleClass.assertions[rule].description,
+            ordinalSeverity: classSeverity + (item.verdict === 'failed' ? 1 : 0),
+            location: {
+              doc: 'dom',
+              type: 'selector',
+              spec: element.pointer
+            },
+            excerpt: cap(element.htmlCode)
+          };
+          standardResult.instances.push(instance);
+        });
+      });
+    });
+  }
+};
+// Converts instances of a wave rule category.
+const doWAVE = (result, standardResult, categoryName) => {
+  if (result.categories && result.categories[categoryName]) {
+    const category = result.categories[categoryName];
+    const ordinalSeverity = categoryName === 'alert' ? 0 : 1;
+    Object.keys(category.items).forEach(rule => {
+      category.items[rule].selectors.forEach(selector => {
+        const instance = {
+          issueID: rule,
+          what: category.items[rule].description,
+          ordinalSeverity,
+          location: {
+            doc: 'dom',
+            type: 'selector',
+            spec: selector
+          },
+          excerpt: ''
+        };
+        standardResult.instances.push(instance);
+      });
+    });
+  }
+};
+// Converts a result.
+const convert = (testName, result, standardResult) => {
+  // alfa
+  if (testName === 'alfa' && result.totals) {
+    standardResult.totals = [result.totals.warnings, result.totals.failures];
+    result.items.forEach(item => {
+      const instance = {
+        issueID: item.rule.ruleID,
+        what: item.rule.ruleSummary,
+        ordinalSeverity: ['cantTell', 'failed'].indexOf(item.verdict),
+        location: {
+          doc: 'dom',
+          type: 'xpath',
+          spec: item.target.path
+        },
+        excerpt: cap(item.target.codeLines.join(' '))
+      };
+      standardResult.instances.push(instance);
+    });
+  }
+  // axe
+  else if (
+    testName === 'axe'
+    && result.totals
+    && (result.totals.rulesWarned || result.totals.rulesViolated)
+  ) {
+    const {totals} = result;
+    standardResult.totals = [
+      totals.warnings.minor,
+      totals.warnings.moderate,
+      totals.warnings.serious,
+      totals.warnings.critical,
+      totals.violations.minor,
+      totals.violations.moderate,
+      totals.violations.serious,
+      totals.violations.critical
+    ];
+    doAxe(result, standardResult, 'incomplete');
+    doAxe(result, standardResult, 'violations');
+  }
+  // continuum
+  else if (testName === 'continuum' && Array.isArray(result) && result.length) {
+    standardResult.totals = [result.length];
+    result.forEach(item => {
+      const instance = {
+        issueID: item.engineTestId.toString(),
+        what: item.attributeDetail,
+        ordinalSeverity: 0,
+        location: {
+          doc: 'dom',
+          type: 'selector',
+          spec: item.path
+        },
+        excerpt: item.element
+      };
+      standardResult.instances.push(instance);
+    });
+  }
+  // htmlcs
+  else if (testName === 'htmlcs' && result) {
+    doHTMLCS(result, standardResult, 'Warning');
+    doHTMLCS(result, standardResult, 'Error');
+    const {instances} = standardResult;
+    standardResult.totals = [
+      instances.filter(instance => instance.ordinalSeverity === 0).length,
+      instances.filter(instance => instance.ordinalSeverity === 1).length
+    ];
+  }
+  // ibm
+  else if (testName === 'ibm' && result.totals) {
+    standardResult.totals = [result.totals.recommendation, result.totals.violation];
+    result.items.forEach(item => {
+      const instance = {
+        issueID: item.ruleId,
+        what: item.message,
+        ordinalSeverity: ['recommendation', 'violation'].indexOf(item.level),
+        location: {
+          doc: 'dom',
+          type: 'xpath',
+          spec: item.path.dom
+        },
+        excerpt: cap(item.snippet)
+      };
+      standardResult.instances.push(instance);
+    });
+  }
+  // nuVal
+  else if (testName === 'nuVal' && (result.pageContent || result.rawPage)) {
+    if (result.pageContent) {
+      doNuVal(result, standardResult, 'pageContent');
+    }
+    if (result.rawPage) {
+      doNuVal(result, standardResult, 'rawPage');
+    }
+    const {instances} = standardResult;
+    standardResult.totals = [
+      instances.filter(instance => instance.ordinalSeverity === 0).length,
+      instances.filter(instance => instance.ordinalSeverity === 1).length,
+      instances.filter(instance => instance.ordinalSeverity === 2).length
+    ];
+  }
+  // qualWeb
+  else if (
+    testName === 'qualWeb'
+    && result.modules
+    && (
+      result.modules['act-rules']
+      || result.modules['wcag-techniques']
+      || result.modules['best-practices']
+    )
+  ) {
+    standardResult.totals = [0, 0, 0, 0, 0, 0];
+    if (result.modules['act-rules']) {
+      doQualWeb(result, standardResult, 'act-rules');
+    }
+    if (result.modules['wcag-techniques']) {
+      doQualWeb(result, standardResult, 'wcag-techniques');
+    }
+    if (result.modules['best-practices']) {
+      doQualWeb(result, standardResult, 'best-practices');
+    }
+  }
+  // tenon
+  else if (testName === 'tenon' && result.data && result.data.resultSet) {
+    result.data.resultSet.forEach(item => {
+      const instance = {
+        issueID: item.tID ? item.tID.toString() : '',
+        what: item.errorTitle || '',
+        ordinalSeverity: Math.min(
+          5, Math.max(0, Math.round((item.certainty || 0) * (item.priority || 0) / 2000))
+        ),
+        location: {
+          doc: 'dom',
+          type: 'xpath',
+          spec: item.xpath || ''
+        },
+        excerpt: cap(item.errorSnippet || '')
+      };
+      standardResult.instances.push(instance);
+    });
+    standardResult.totals = [0, 0, 0, 0, 0, 0];
+    standardResult.instances.forEach(instance => {
+      standardResult.totals[instance.ordinalSeverity]++;
+    });
+  }
+  // testaro
+  else if (testName === 'testaro') {
+    const rules = Object.keys(result.rules);
+    standardResult.totals = [0, 0, 0, 0];
+    rules.forEach(rule => {
+      const ruleResult = result.rules[rule];
+      standardResult.totals.forEach((total, index) => {
+        standardResult.totals[index] += ruleResult.totals[index];
+      });
+      standardResult.instances.push(... ruleResult.standardInstances);
+    });
+    standardResult.totals = standardResult.totals.map(total => Math.round(total));
+  }
+  // wave
+  else if (
+    testName === 'wave'
+    && result.categories
+    && (
+      result.categories.error
+      || result.categories.contrast
+      || result.categories.alert
+    )
+  ) {
+    const {categories} = result;
+    standardResult.totals = [
+      categories.alert.count || 0, (categories.error.count || 0) + (categories.contrast.count || 0)
+    ];
+    ['error', 'contrast', 'alert'].forEach(categoryName => {
+      doWAVE(result, standardResult, categoryName);
+    });
+  }
+};
+// Converts the results.
+exports.standardize = act => {
+  const {which} = act;
+  const {result, standardResult} = act;
+  convert(which, result, standardResult);
+};

package/{tests → testaro}/allHidden.js

@@ -45,5 +45,40 @@ exports.reporter = async page => {
     });
     return data;
   });
-  return {result: data};
+  const standardInstances = [];
+  const reportables = {
+    hidden: [0, 'hidden'],
+    reallyHidden: [1, 'effectively hidden'],
+    visHidden: [0, 'visually hidden'],
+    ariaHidden: [1, 'hidden by ARIA'],
+    document: [1, 'Document', 'document.documentElement'],
+    body: [1, 'Document body', 'document.body'],
+    main: [0, 'main region', 'main, [role="main"]']
+  };
+  ['document', 'body', 'main'].forEach(region => {
+    ['hidden', 'reallyHidden', 'visHidden', 'ariaHidden'].forEach(hider => {
+      if (data[hider][region]) {
+        standardInstances.push({
+          issueID: `allHidden-${hider}-${region}`,
+          what: `${reportables[region][1]} ${reportables[hider][1]}`,
+          ordinalSeverity: reportables[region][0] + reportables[hider][0] || 0,
+          location: {
+            doc: 'dom',
+            type: 'selector',
+            spec: reportables[region][2]
+          },
+          excerpt: ''
+        });
+      }
+    });
+  });
+  const totals = [0, 0, 0, 0];
+  standardInstances.forEach(instance => {
+    totals[instance.ordinalSeverity]++;
+  });
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/attVal.js

@@ -2,7 +2,8 @@
   attVal
   This test reports attributes with illicit values.
 */
-exports.reporter = async (page, attributeName, areLicit, values, withItems) => {
+exports.reporter = async (page, withItems, attributeName, areLicit, values) => {
+  console.log('Starting reporter');
   // Identify the elements that have the specified attribute with illicit values.
   const badAttributeData = await page.evaluate(
     async args => {
@@ -41,8 +42,41 @@ exports.reporter = async (page, attributeName, areLicit, values, withItems) => {
   const data = {
     total: badAttributeData.length
   };
+  const standardInstances = [];
   if (withItems) {
     data.items = badAttributeData;
+    badAttributeData.forEach(item => {
+      standardInstances.push({
+        issueID: `attVal-${item.tagName}-${attributeName}`,
+        what:
+          `${item.tagName} element has attribute ${attributeName} with illicit value ${item.attributeValue}`,
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: item.textStart
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'attVal',
+      what: 'Elements have attributes with illicit values',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
   }
-  return {result: data};
+  const totals = [0, 0, data.total, 0];
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/autocomplete.js

@@ -70,6 +70,39 @@ exports.reporter = async (page, withItems) => {
       }
     }
   }
+  const standardInstances = [];
+  if (data.items) {
+    data.items.forEach(item => {
+      standardInstances.push({
+        issueID: `autocomplete-${item[0]}`,
+        what: `Input is missing the required autocomplete attribute with value ${item[0]}`,
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: item[1]
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'autocomplete',
+      what: 'Inputs are missing required autocomplete attributes',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
   // Return the data.
-  return {result: data};
+  return {
+    data,
+    totals: [0, 0, data.total, 0],
+    standardInstances
+  };
 };

package/{tests → testaro}/bulk.js

@@ -18,5 +18,19 @@ exports.reporter = async page => {
   });
   const visibleElements = await page.$$('body :visible');
   data.visibleElements = visibleElements.length;
-  return {result: data};
+  return {
+    data,
+    totals: [Math.round(data.visibleElements / 400), 0, 0, 0],
+    standardInstances: data.visibleElements < 200 ? [] : [{
+      issueID: 'bulk',
+      what: 'Page contains a large number of visible elements',
+      ordinalSeverity: 0,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    }]
+  };
 };

package/{tests → testaro}/docType.js

@@ -10,5 +10,19 @@ exports.reporter = async page => {
     const docHasType = !! docType && docType.name && docType.name.toLowerCase() === 'html';
     return docHasType;
   });
-  return {result: {docHasType}};
+  return {
+    data: {docHasType},
+    totals: [0, 0, 0, docHasType ? 0 : 1],
+    standardInstances: docHasType ? [] : [{
+      issueID: 'docType',
+      what: 'Document has no standard HTML doctype preamble',
+      ordinalSeverity: 3,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    }]
+  };
 };

package/{tests → testaro}/dupAtt.js

@@ -76,6 +76,39 @@ exports.reporter = async (page, withItems) => {
       }
     }
   });
+  const standardInstances = [];
+  if (data.items) {
+    data.items.forEach(item => {
+      standardInstances.push({
+        issueID: 'dupAtt',
+        what: `Element ${item.tagName} has 2 attributes with the same name`,
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: item.attributes.join(' ... ')
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'dupAtt',
+      what: 'In some elements 2 attributes have the same name',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
   // Return the data.
-  return {result: data};
+  return {
+    data,
+    totals: [0, 0, data.total, 0],
+    standardInstances
+  };
 };

package/{tests → testaro}/elements.js

@@ -1,13 +1,15 @@
 /*
   elements
-  This test reports data about specified elements.
+  This test reports data about specified elements within the document body.
   Meanings of detailLevel values:
     0. Only total element count; no detail.
     1. Also data on each specified element.
     2. Data on each specified element also include the text content of the parent element.
     3. Data on each specified element also include data on its sibling nodes.
 */
-exports.reporter = async (page, detailLevel, tagName, onlyVisible, attribute) => {
+exports.reporter = async (
+  page, withItems, detailLevel = 0, tagName = null, onlyVisible = false, attribute
+) => {
   // Determine a selector of the specified elements, including any descendants of open shadow roots.
   let selector = `body ${tagName ? tagName.toLowerCase() : '*'}`;
   if (attribute) {
@@ -155,5 +157,9 @@ exports.reporter = async (page, detailLevel, tagName, onlyVisible, attribute) =>
     };
   }
   // Return the result.
-  return {result: data};
+  return {
+    data,
+    totals: [],
+    standardInstances: []
+  };
 };

package/testaro/embAc.js

@@ -0,0 +1,78 @@
+/*
+  embAc
+  This test reports interactive elements (links, buttons, inputs, and select lists)
+  contained by links or buttons. Such embedding not only violates the HTML standard,
+  but also complicates user interaction and creates risks of error. It becomes
+  non-obvious what a user will activate with a click.
+*/
+exports.reporter = async (page, withItems) => await page.$$eval(
+  'a a, a button, a input, a select, button a, button button, button input, button select',
+  (bads, withItems) => {
+    // FUNCTION DEFINITION START
+    // Returns a space-minimized copy of a string.
+    const compact = string => string.replace(/[\t\n]/g, '').replace(/\s{2,}/g, ' ').trim();
+    // FUNCTION DEFINITION END
+    const totals = {
+      links: 0,
+      buttons: 0,
+      inputs: 0,
+      selects: 0
+    };
+    const items = [];
+    // Total and, if requested, itemize the faulty elements.
+    bads.forEach(bad => {
+      totals[Object.keys(totals)[['A', 'BUTTON', 'INPUT', 'SELECT'].indexOf(bad.tagName)]]++;
+      let container;
+      if (withItems) {
+        if (['A', 'BUTTON'].includes(bad.parentElement.tagName)) {
+          container = bad.parentElement;
+        }
+        else {
+          container = bad.parentElement.parentElement;
+        }
+        items.push({
+          embeddedElement: bad.tagName,
+          excerpt: compact(container.outerHTML)
+        });
+      }
+    });
+    // Return the result.
+    const data = {totals};
+    const standardInstances = [];
+    const total = Object.values(data.totals).reduce((sum, current) => sum + current);
+    if (withItems) {
+      data.items = items;
+      items.forEach(item => {
+        standardInstances.push({
+          issueID: `embAc-${item.embeddedElement}`,
+          what: `Element ${item.embeddedElement} is embedded in a link or button`,
+          ordinalSeverity: 2,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: item.excerpt
+        });
+      });
+    }
+    else if (total) {
+      standardInstances.push({
+        issueID: 'embAc',
+        what: 'Interactive elements are contained by links or buttons',
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      });
+    }
+    return {
+      data,
+      totals: [0, 0, total, 0],
+      standardInstances
+    };
+  }, withItems
+);