testaro 65.0.4 → 65.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "65.0.4",
+  "version": "65.1.0",
   "description": "Run 1000 web accessibility tests from 11 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/standardize.js

@@ -393,66 +393,70 @@ const convert = (toolName, data, result, standardResult) => {
   // alfa
   else if (toolName === 'alfa' && result.totals) {
     result.items.forEach(item => {
-      const {codeLines} = item.target;
+      const {outcome, rule, violator} = item;
+      const {ruleID, ruleSummary} = rule;
+      const {codeLines, path, pathID, tagName, text} = violator;
       const code = Array.isArray(codeLines) ? codeLines.join(' ') : '';
       const identifiers = getIdentifiers(code);
-      const tagNameArray = item.target
-      && item.target.path
-      && item.target.path.match(/^.*\/([a-z]+)\[\d+\]/);
+      const tagNameArray = path && path.match(/^.*\/([a-z]+)\[\d+\]/);
       if (tagNameArray && tagNameArray.length === 2) {
         identifiers[0] = tagNameArray[1].toUpperCase();
       }
-      const {rule, target} = item;
       let instance;
-      if (item.verdict === 'failed') {
+      if (outcome === 'failed') {
         instance = {
-          ruleID: rule.ruleID,
-          what: rule.ruleSummary,
+          ruleID,
+          what: ruleSummary,
           ordinalSeverity: 3,
-          tagName: identifiers[0],
+          tagName: tagName || identifiers[0],
           id: identifiers[1],
           location: {
             doc: 'dom',
             type: 'xpath',
-            spec: target.path
+            spec: path
           },
           excerpt: cap(code),
+          text,
           boxID: '',
-          pathID: ''
+          pathID
         };
         standardResult.instances.push(instance);
       }
       else if (item.verdict === 'cantTell') {
-        if (['r66', 'r69'].includes(rule.ruleID)) {
+        if (['r66', 'r69'].includes(ruleID)) {
           instance = {
             ruleID: 'cantTellTextContrast',
-            what: `cannot test for rule ${rule.ruleID}: ${rule.ruleSummary}`,
+            what: `cannot test for rule ${ruleID}: ${ruleSummary}`,
             ordinalSeverity: 0,
-            tagName: identifiers[0],
+            tagName: tagName || identifiers[0],
             id: identifiers[1],
             location: {
               doc: 'dom',
               type: 'xpath',
-              spec: target.path
+              spec: path
             },
-            excerpt: cap(code)
+            excerpt: cap(code),
+            text,
+            boxID: '',
+            pathID
           };
         }
         else {
           instance = {
             ruleID: 'cantTell',
-            what: `cannot test for rule ${rule.ruleID}: ${rule.ruleSummary}`,
+            what: `cannot test for rule ${ruleID}: ${ruleSummary}`,
             ordinalSeverity: 0,
-            tagName: identifiers[0],
+            tagName: tagName || identifiers[0],
             id: identifiers[1],
             location: {
               doc: 'dom',
               type: 'xpath',
-              spec: target.path
+              spec: path
             },
             excerpt: cap(code),
+            text,
             boxID: '',
-            pathID: ''
+            pathID
           };
         }
         standardResult.instances.push(instance);

package/run.js

@@ -1765,7 +1765,7 @@ const doActs = async (report, opts = {}) => {
               .replace(/ data-testaro-id="[^" ]* /g, ' ');
             }
             pathID = instance.pathID;
-            // If the instance has no text property:
+            // If the instance has no or an empty text property:
             if (! instance.text) {
               const {excerpt} = instance;
               // If the instance has a markup-free non-empty excerpt:

package/tests/alfa.js

@@ -17,12 +17,13 @@
 
 let alfaRules = require('@siteimprove/alfa-rules').default;
 const {Audit} = require('@siteimprove/alfa-act');
+const {getNormalizedXPath} = require('../procs/identify');
 const {Playwright} = require('@siteimprove/alfa-playwright');
 
 // FUNCTIONS
 
 // Simplifies the spacing of a string.
-const tidy = string => string.replace(/\n/g, ' ').replace(/\s+/g, ' ');
+const tidy = string => string.replace(/\s+/g, ' ');
 
 // Conducts and reports the alfa tests.
 exports.reporter = async (page, report, actIndex) => {
@@ -47,35 +48,53 @@ exports.reporter = async (page, report, actIndex) => {
     const doc = await page.evaluateHandle('document');
     const alfaPage = await Playwright.toPage(doc);
     const audit = Audit.of(alfaPage, alfaRules);
-    // Get the test outcomes.
-    const outcomes = Array.from(await audit.evaluate());
-    // For each outcome:
-    outcomes.forEach((outcome, index) => {
-      const {target} = outcome;
-      // If the target exists and is not a collection:
-      if (target && ! target._members) {
-        // Convert the outcome to an object.
-        const outcomeJ = outcome.toJSON();
-        // Get the verdict.
-        const verdict = outcomeJ.outcome;
-        // If the verdict is a failure or warning:
-        if (verdict !== 'passed') {
-          // Add to the result.
-          const {expectations, rule} = outcomeJ;
+    // Get the evaluation.
+    const evaluation = Array.from(await audit.evaluate());
+    // For each of its components:
+    for (const index in evaluation) {
+      const component = evaluation[index];
+      const violatorClass = component.target;
+      // If it has a non-collection violator:
+      if (violatorClass && ! violatorClass._members) {
+        // Get the path.
+        const path = violatorClass.path();
+        // Get the normalized path, omitting any final text() selector.
+        const pathID = getNormalizedXPath(path.replace(/\/text\(\).*$/, ''));
+        // Get the code lines of the violator.
+        const codeLines = violatorClass.toString().split('\n');
+        // Convert the component to a finding object.
+        const finding = component.toJSON();
+        const {expectations, outcome, rule} = finding;
+        // If the outcome of the finding is a failure or warning:
+        if (outcome !== 'passed') {
+          let text = '';
+          // Get a locator for the violator.
+          const violatorLoc = page.locator(`xpath=${pathID}`);
+          try {
+            // Get the inner text of the violator.
+            text = await violatorLoc.innerText({timeout: 50});
+          }
+          catch(error) {}
           const {tags, uri, requirements} = rule;
           const ruleID = uri.replace(/^.+-/, '');
           let ruleSummary = tidy(expectations?.[0]?.[1]?.error?.message || '');
-          const targetJ = outcomeJ.target;
-          const codeLines = target.toString().split('\n');
+          const violator = finding.target;
+          const {name, type} = violator;
           if (codeLines[0] === '#document') {
             codeLines.splice(2, codeLines.length - 3, '...');
           }
           else if (codeLines[0].startsWith('<html')) {
             codeLines.splice(1, codeLines.length - 2, '...');
           }
-          const outcomeData = {
+          let tagName = name?.toUpperCase();
+          if (pathID && (tagName?.startsWith('TEXT') || ! tagName)) {
+            const standardTagName = pathID.split('/').pop().replace(/\[.+/, '').toUpperCase() || '';
+            tagName = standardTagName;
+          }
+          // Get data on the finding.
+          const findingData = {
             index,
-            verdict,
+            outcome,
             rule: {
               ruleID,
               ruleSummary,
@@ -83,46 +102,49 @@ exports.reporter = async (page, report, actIndex) => {
               uri,
               requirements
             },
-            target: {
-              type: targetJ.type,
-              tagName: targetJ.name || '',
-              path: target.path(),
+            violator: {
+              type,
+              name,
+              tagName,
+              path,
               codeLines: codeLines.map(
                 line => line.length > 300 ? `${line.slice(0, 300)}...` : line
-              )
+              ),
+              text,
+              pathID
             }
           };
           // If the rule summary is missing:
-          if (outcomeData.rule.ruleSummary === '') {
+          if (findingData.rule.ruleSummary === '') {
             // If a first requirement title exists:
-            const {requirements} = outcomeData.rule;
+            const {requirements} = findingData.rule;
             if (requirements && requirements.length && requirements[0].title) {
               // Make it the rule summary.
-              outcomeData.rule.ruleSummary = requirements[0].title;
+              findingData.rule.ruleSummary = requirements[0].title;
             }
           }
           const etcTags = [];
           tags.forEach(tag => {
             if (tag.type === 'scope') {
-              outcomeData.rule.scope = tag.scope;
+              findingData.rule.scope = tag.scope;
             }
             else {
               etcTags.push(tag);
             }
           });
           if (etcTags.length) {
-            outcomeData.etcTags = etcTags;
+            findingData.etcTags = etcTags;
           }
-          if (outcomeData.verdict === 'failed') {
+          if (findingData.outcome === 'failed') {
             result.totals.failures++;
           }
-          else if (outcomeData.verdict === 'cantTell') {
+          else if (findingData.outcome === 'cantTell') {
             result.totals.warnings++;
           }
-          result.items.push(outcomeData);
+          result.items.push(findingData);
         }
       }
-    });
+    };
   }
   catch(error) {
     console.log(`ERROR: Navigation to URL timed out (${error})`);