testaro 13.0.2 → 14.1.0

package/{tests → testaro}/motion.js

@@ -63,7 +63,7 @@ const shootAll = async (page, delay, interval, count, toDo, buffers) => {
 // Returns a number rounded to 2 decimal digits.
 const round = (num, precision) => Number.parseFloat(num.toPrecision(precision));
 // Reports motion in a page.
-exports.reporter = async (page, delay, interval, count) => {
+exports.reporter = async (page, withItems, delay = 2500, interval = 2500, count = 5) => {
   // Make screenshots and get their image buffers.
   const shots = await shootAll(page, delay, interval, count, count, []);
   // If the shooting succeeded:
@@ -99,7 +99,7 @@ exports.reporter = async (page, delay, interval, count) => {
     );
     // Return the result.
     return {
-      result: {
+      data: {
         bytes,
         localRatios,
         meanLocalRatio,
@@ -109,14 +109,37 @@ exports.reporter = async (page, delay, interval, count) => {
         meanPixelChange,
         maxPixelChange,
         changeFrequency
-      }
+      },
+      totals: [
+        0,
+        0, 
+        2 * (meanLocalRatio - 1)
+        + maxLocalRatio - 1
+        + globalRatio - 1
+        + meanPixelChange / 10000
+        + maxPixelChange / 25000
+        + 3 * changeFrequency
+        || 0,
+        0
+      ],
+      standardInstances: [{
+        issueID: 'motion',
+        what: 'Content moves or changes without user request',
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      }]
     };
   }
   // Otherwise, i.e. if the shooting failed:
   else {
     // Return failure.
     return {
-      result: {
+      data: {
         prevented: true,
         error: 'ERROR: screenshots failed'
       }

package/{tests → testaro}/nonTable.js

@@ -60,8 +60,39 @@ exports.reporter = async (page, withItems) => {
   const data = {
     total: badTableTexts.length
   };
+  const standardInstances = [];
   if (withItems) {
     data.items = badTableTexts;
+    data.items.forEach(text => {
+      standardInstances.push({
+        issueID: 'nonTable',
+        what: 'Table is misused to arrange content',
+        ordinalSeverity: 0,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: text
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'nonTable',
+      what: 'Tables are misused to arrange content',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
   }
-  return {result: data};
+  return {
+    data,
+    totals: [0, 0, data.total, 0],
+    standardInstances
+  };
 };

package/{tests → testaro}/radioSet.js

@@ -75,18 +75,49 @@ exports.reporter = async (page, withItems) => {
       totals.inSet = setRadios.length;
       totals.percent = totals.total ? Math.floor(100 * totals.inSet / totals.total) : 'N.A.';
       // If itemization is required:
+      const standardInstances = [];
       if (withItems) {
         // Add it to the results.
         const nonSetRadios = allRadios.filter(radio => ! setRadios.includes(radio));
         const items = data.items;
         items.inSet = setRadios.map(radio => textOf(radio));
         items.notInSet = nonSetRadios.map(radio => textOf(radio));
+        items.notInSet.forEach(text => {
+          standardInstances.push({
+            issueID: 'radioSet',
+            what: 'Radio button and others with its name are not grouped in their own fieldset with a legend',
+            ordinalSeverity: 0,
+            location: {
+              doc: '',
+              type: '',
+              spec: ''
+            },
+            excerpt: text
+          });
+        });
       }
-      return {result: data};
+      else if (totals.total - totals.inSet > 0) {
+        standardInstances.push({
+          issueID: 'radioSet',
+          what: 'Radio buttons are not validly grouped in fieldsets with legends',
+          ordinalSeverity: 1,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: ''
+        });
+      }
+      return {
+        data,
+        totals: [0, totals.total - totals.inSet, 0, 0],
+        standardInstances
+      };
     }
     else {
       return {
-        result: {
+        data: {
           prevented: true,
           error: 'ERROR identifying homogeneous field sets'
         }

package/{tests → testaro}/role.js

@@ -478,6 +478,43 @@ exports.reporter = async page => await page.$eval('body', body => {
       }
     }
   });
+  const standardInstances = [];
+  Object.keys(data.tagNames).forEach(tagName => {
+    Object.keys(data.tagNames[tagName]).forEach(role => {
+      let count = data.tagNames[tagName][role].redundant;
+      if (count) {
+        standardInstances.push({
+          issueID: 'role',
+          what: `Elements ${tagName} have redundant explicit role ${role} (count: ${count})`,
+          ordinalSeverity: 1,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: ''
+        });
+      }
+      count = data.tagNames[tagName][role].bad;
+      if (count) {
+        standardInstances.push({
+          issueID: 'role',
+          what: `Elements ${tagName} have invalid or native-replaceable explicit role ${role} (count: ${count})`,
+          ordinalSeverity: 3,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: ''
+        });
+      }
+    });
+  });
   // Return the result.
-  return {result: data};
+  return {
+    data,
+    totals: [0, data.redundantRoleElements, 0, data.badRoleElements],
+    standardInstances
+  };
 });

package/{tests → testaro}/styleDiff.js

@@ -107,7 +107,9 @@ exports.reporter = async (page, withItems) => {
             if (! styleProps[typeName]) {
               styleProps[typeName] = {};
             }
-            const elementText = element.textContent.trim().replace(/\s/g, ' ');
+            const elementText = (element.textContent.trim() || element.outerHTML.trim())
+            .replace(/\s+/g, ' ')
+            .slice(0, 100);
             // For each style property being compared:
             styles.forEach(styleName => {
               if (! styleProps[typeName][styleName]) {
@@ -116,6 +118,7 @@ exports.reporter = async (page, withItems) => {
               if (! styleProps[typeName][styleName][style[styleName]]) {
                 styleProps[typeName][styleName][style[styleName]] = [];
               }
+              // Add the element text to the style details.
               styleProps[typeName][styleName][style[styleName]].push(elementText);
             });
           }
@@ -148,6 +151,44 @@ exports.reporter = async (page, withItems) => {
     headingNames.forEach(headingName => {
       tallyStyles(headingName, elements.headings[headingName], headingStyles, withItems);
     });
-    return {result: data};
+    // Report the standandardized data.
+    const totals = [0, 0, 0, 0];
+    const standardInstances = [];
+    const elementData = {
+      adjacentLink: [0, 'In-line links'],
+      listLink: [1, 'Links in columns'],
+      button: [2, 'Buttons'],
+      h1: [3, 'Level-1 headings'],
+      h2: [3, 'Level-2 headings'],
+      h3: [3, 'Level-3 headings'],
+      h4: [3, 'Level-4 headings'],
+      h5: [3, 'Level-5 headings'],
+      h6: [3, 'Level-6 headings'],
+    };
+    Object.keys(elementData).forEach(elementName => {
+      const elementTotal = data.totals[elementName];
+      if (elementTotal && elementTotal.subtotals) {
+        const currentData = elementData[elementName];
+        const severity = currentData[0];
+        const elementSubtotals = elementTotal.subtotals;
+        totals[severity] += elementSubtotals.length - 1;
+        standardInstances.push({
+          issueID: 'styleDiff',
+          what: `${currentData[1]} have ${elementSubtotals.length} different styles`,
+          ordinalSeverity: severity,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: ''
+        });
+      }
+    });
+    return {
+      data,
+      totals,
+      standardInstances
+    };
   }, [linkTypes, withItems]);
 };

package/{tests → testaro}/tabNav.js

@@ -324,5 +324,46 @@ exports.reporter = async (page, withItems) => {
     // FUNCTION DEFINITIONS END
     await testTabLists(tabLists);
   }
-  return {result: data};
+  const totals = data.totals ? [
+    data.totals.navigations.all.incorrect,
+    data.totals.tabElements.incorrect,
+    data.totals.tabLists.incorrect,
+    0
+  ] : [];
+  const standardInstances = [];
+  if (data.tabElements && data.tabElements.incorrect) {
+    data.tabElements.incorrect.forEach(item => {
+      standardInstances.push({
+        issueID: 'tabNav',
+        what: `Element ${item.tagName} has a tab role but has nonstandard navigation`,
+        ordinalSeverity: 1,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: `${item.tagName}: ${item.text}`
+      });
+    });
+  }
+  else if (data.totals.navigations.all.incorrect) {
+    standardInstances.push({
+      issueID: 'tabNav',
+      what: 'Tablists have nonstandard navigation',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  // Reload the page.
+  await page.reload({timeout: 15000});
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/textNodes.js

@@ -6,7 +6,7 @@
     1-3. Count of ancestry levels to provide data on (1 = text node, 2 = also parent,
       3 = also grandparent)
 */
-exports.reporter = async (page, detailLevel, text = '') => {
+exports.reporter = async (page, withItems, detailLevel, text = '') => {
   let data = {};
   // Get the data on the text nodes.
   try {
@@ -136,5 +136,9 @@ exports.reporter = async (page, detailLevel, text = '') => {
     };
   }
   // Return the result.
-  return {result: data};
+  return {
+    data,
+    totals: [],
+    standardInstances: []
+  };
 };

package/{tests → testaro}/title.js

@@ -4,8 +4,12 @@
 */
 exports.reporter = async page => {
   const title = await page.title();
-  return {result: {
-    success: true,
-    title
-  }};
+  return {
+    data: {
+      success: true,
+      title
+    },
+    totals: [],
+    standardInstances: []
+  };
 };

package/{tests → testaro}/titledEl.js

@@ -24,8 +24,39 @@ exports.reporter = async (page, withItems) => {
   const data = {
     total: badTitleElements.length
   };
+  const standardInstances = [];
   if (withItems) {
     data.items = badTitleElements;
+    badTitleElements.forEach(element => {
+      standardInstances.push({
+        issueID: 'titledEl',
+        what: `Element ${element.tagName} has a title attribute`,
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: `${element.tagName} (${element.text}): ${element.title}`
+      });
+    });
   }
-  return {result: data};
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'titledEl',
+      what: 'Ineligible elements have title attributes',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals: [0, 0, data.total, 0],
+    standardInstances
+  };
 };

package/{tests → testaro}/zIndex.js

@@ -33,7 +33,10 @@ exports.reporter = async (page, withItems) => {
         data.items.push({
           tagName,
           id: element.id || '',
-          text: element.textContent.trim().replace(/\s{2,}/g, ' ').slice(0, 100)
+          text:
+          (element.textContent.trim() || element.outerHTML.trim())
+          .replace(/\s+/g, ' ')
+          .slice(0, 100)
         });
       }
     };
@@ -45,5 +48,40 @@ exports.reporter = async (page, withItems) => {
     });
     return data;
   }, withItems);
-  return {result: data};
+  const standardInstances = [];
+  if (data.items) {
+    data.items.forEach(item => {
+      const itemID = item.id ? ` (ID ${item.id})` : '';
+      const which = `${item.tagName}${itemID}`;
+      standardInstances.push({
+        issueID: 'zIndex',
+        what: `Element ${item.tagName} has a non-default Z index`,
+        ordinalSeverity: 0,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: `${which}: ${item.text}`
+      });
+    });
+  }
+  else if (data.totals.total) {
+    standardInstances.push({
+      issueID: 'zIndex',
+      what: 'Elements have non-default Z indexes',
+      ordinalSeverity: 0,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals: [data.totals.total, 0, 0, 0],
+    standardInstances
+  };
 };

package/tests/alfa.js

@@ -6,7 +6,7 @@
 // IMPORTS
 
 const {Audit} = require('@siteimprove/alfa-act');
-const {Scraper} = require('@siteimprove/alfa-scraper');
+const {Playwright} = require('@siteimprove/alfa-playwright');
 let alfaRules = require('@siteimprove/alfa-rules').default;
 
 // FUNCTIONS
@@ -25,8 +25,16 @@ exports.reporter = async (page, rules) => {
     const msgText = msg.text();
     console.log(msgText);
   });
+  // Initialize the result.
+  let data = {
+    totals: {
+      failures: 0,
+      warnings: 0
+    },
+    items: []
+  };
   try {
-    const response = await rulePage.goto('https://alfa.siteimprove.com/rules', {timeout: 10000});
+    const response = await rulePage.goto('https://alfa.siteimprove.com/rules', {timeout: 15000});
     let ruleData = {};
     if (response.status() === 200) {
       // Compile data on the rule IDs and summaries.
@@ -49,90 +57,79 @@ exports.reporter = async (page, rules) => {
       });
       await rulePage.close();
     }
-    // Initialize the result.
-    const data = {
-      totals: {
-        failures: 0,
-        warnings: 0
-      },
-      items: []
-    };
-    await Scraper.with(async scraper => {
-      // Get the page content.
-      for (const input of await scraper.scrape(page.url())) {
-        // Test it with the specified rules.
-        const audit = Audit.of(input, alfaRules);
-        const outcomes = Array.from(await audit.evaluate());
-        // For each failure or warning:
-        outcomes.forEach((outcome, index) => {
-          const {target} = outcome;
-          if (target && ! target._members) {
-            const outcomeJ = outcome.toJSON();
-            const verdict = outcomeJ.outcome;
-            if (verdict !== 'passed') {
-              // Add to the result.
-              const {rule} = outcomeJ;
-              const {tags, uri, requirements} = rule;
-              const ruleID = uri.replace(/^.+-/, '');
-              const ruleSummary = ruleData[ruleID] || '';
-              const targetJ = outcomeJ.target;
-              const codeLines = target.toString().split('\n');
-              if (codeLines[0] === '#document') {
-                codeLines.splice(2, codeLines.length - 3, '...');
-              }
-              else if (codeLines[0].startsWith('<html')) {
-                codeLines.splice(1, codeLines.length - 2, '...');
-              }
-              const outcomeData = {
-                index,
-                verdict,
-                rule: {
-                  ruleID,
-                  ruleSummary,
-                  scope: '',
-                  uri,
-                  requirements
-                },
-                target: {
-                  type: targetJ.type,
-                  tagName: targetJ.name || '',
-                  path: target.path(),
-                  codeLines: codeLines.map(line => line.length > 300 ? `${line.slice(0, 300)}...` : line)
-                }
-              };
-              const etcTags = [];
-              tags.forEach(tag => {
-                if (tag.type === 'scope') {
-                  outcomeData.rule.scope = tag.scope;
-                }
-                else {
-                  etcTags.push(tag);
-                }
-              });
-              if (etcTags.length) {
-                outcomeData.etcTags = etcTags;
-              }
-              if (outcomeData.verdict === 'failed') {
-                data.totals.failures++;
-              }
-              else if (outcomeData.verdict === 'cantTell') {
-                data.totals.warnings++;
-              }
-              data.items.push(outcomeData);
+    // Test the page content with the specified rules.
+    const doc = await page.evaluateHandle('document');
+    const alfaPage = await Playwright.toPage(doc);
+    const audit = Audit.of(alfaPage, alfaRules);
+    const outcomes = Array.from(await audit.evaluate());
+    // For each failure or warning:
+    outcomes.forEach((outcome, index) => {
+      const {target} = outcome;
+      if (target && ! target._members) {
+        const outcomeJ = outcome.toJSON();
+        const verdict = outcomeJ.outcome;
+        if (verdict !== 'passed') {
+          // Add to the result.
+          const {rule} = outcomeJ;
+          const {tags, uri, requirements} = rule;
+          const ruleID = uri.replace(/^.+-/, '');
+          const ruleSummary = ruleData[ruleID] || '';
+          const targetJ = outcomeJ.target;
+          const codeLines = target.toString().split('\n');
+          if (codeLines[0] === '#document') {
+            codeLines.splice(2, codeLines.length - 3, '...');
+          }
+          else if (codeLines[0].startsWith('<html')) {
+            codeLines.splice(1, codeLines.length - 2, '...');
+          }
+          const outcomeData = {
+            index,
+            verdict,
+            rule: {
+              ruleID,
+              ruleSummary,
+              scope: '',
+              uri,
+              requirements
+            },
+            target: {
+              type: targetJ.type,
+              tagName: targetJ.name || '',
+              path: target.path(),
+              codeLines: codeLines.map(line => line.length > 300 ? `${line.slice(0, 300)}...` : line)
+            }
+          };
+          const etcTags = [];
+          tags.forEach(tag => {
+            if (tag.type === 'scope') {
+              outcomeData.rule.scope = tag.scope;
             }
+            else {
+              etcTags.push(tag);
+            }
+          });
+          if (etcTags.length) {
+            outcomeData.etcTags = etcTags;
           }
-        });
+          if (outcomeData.verdict === 'failed') {
+            data.totals.failures++;
+          }
+          else if (outcomeData.verdict === 'cantTell') {
+            data.totals.warnings++;
+          }
+          data.items.push(outcomeData);
+        }
       }
     });
-    return {result: data};
   }
   catch(error) {
     console.log(`ERROR: navigation to URL timed out (${error})`);
-    return {
+    data = {
       result: {
         prevented: true,
         error: 'ERROR: navigation to URL timed out'
       }
     };
   }
+  return {result: data};
 };

package/tests/continuum.js

@@ -43,12 +43,16 @@ exports.reporter = async (page, rules) => {
         }, 30000);
       });
       const bigResult = await Promise.race([bigResultPromise, deadlinePromise]);
+      // If the result compilation succeeded:
       if (Array.isArray(bigResult)) {
+        // Return a compact version of it, removing useless and invariant properties.
         return bigResult.map(bigItem => {
           const item = bigItem._rawEngineJsonObject;
+          delete item.testResult;
+          delete item.fixType;
           delete item.fingerprint.encoding;
-          if (item.element.length > 200) {
-            item.element = `${item.element.slice(0, 100)} ... ${item.element.slice(-100)}`;
+          if (item.element.length > 240) {
+            item.element = `${item.element.slice(0, 200)} ... ${item.element.slice(-200)}`;
           }
           return item;
         });