testaro 13.0.2 → 14.1.0

package/{tests → testaro}/filter.js

@@ -43,5 +43,39 @@ exports.reporter = async (page, withItems) => {
     }
     return data;
   }, withItems);
-  return {result: data};
+  const totals = [0, data.totals.impactedElements, data.totals.styledElements, 0, 0];
+  const standardInstances = [];
+  if (data.items) {
+    data.items.forEach(item => {
+      standardInstances.push({
+        issueID: 'filterStyle',
+        what: `Element ${item.tagName} has a filter style that impacts ${item.impact} elements`,
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: `${item.tagName}: ${item.text}`
+      });
+    });
+  }
+  else if (data.totals.styledElements) {
+    standardInstances.push({
+      issueID: 'filterStyle',
+      what: 'Elements have filter styles impacting other elements',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/focAll.js

@@ -48,10 +48,27 @@ exports.reporter = async page => {
       refocused++;
     }
   }
-  // Return the result.
-  return {result: {
+  const data = {
     tabFocusables,
     tabFocused,
     discrepancy: tabFocused - tabFocusables
-  }};
+  };
+  // Reload the page.
+  await page.reload({timeout: 15000});
+  // Return the result.
+  return {
+    data,
+    totals: [0, 0, Math.abs(data.discrepancy), 0],
+    standardInstances: data.discrepancy ? [{
+      issueID: 'focAll',
+      what: 'Some focusable elements are not Tab-focusable or vice versa',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    }] : []
+  };
 };

package/{tests → testaro}/focInd.js

@@ -13,7 +13,7 @@
 
   WARNING: This test fails to recognize outlines when run with firefox.
 */
-exports.reporter = async (page, revealAll, allowedDelay, withItems) => {
+exports.reporter = async (page, withItems, revealAll = false, allowedDelay = 250) => {
   // If required, make all elements visible.
   if (revealAll) {
     await require('../procs/allVis').allVis(page);
@@ -67,7 +67,8 @@ exports.reporter = async (page, revealAll, allowedDelay, withItems) => {
       if (withItems) {
         const elementData = {
           tagName,
-          text: element.textContent.trim().replace(/\s{2,}/g, ' ').slice(0, 100)
+          text: (element.textContent.trim() || element.outerHTML.trim()).replace(/\s+/g, ' ')
+          .slice(0, 100)
         };
         if (status === 'outlinePresent') {
           elementData.delay = delay;
@@ -163,5 +164,46 @@ exports.reporter = async (page, revealAll, allowedDelay, withItems) => {
     }
     return data;
   }, [allowedDelay, withItems]);
-  return {result: data};
+  const {types} = data.totals;
+  const totals = [0, 0, types.nonOutlinePresent.total, types.indicatorMissing.total];
+  const standardInstances = [];
+  if (data.items) {
+    const issueNames = ['nonOutlinePresent', 'indicatorMissing'];
+    issueNames.forEach(issueName => {
+      data.items[issueName].forEach(item => {
+        const qualifier = issueName === 'nonOutlinePresent' ? 'a non-outline' : 'no';
+        standardInstances.push({
+          issueID: `focInd-${issueName}`,
+          what: `Element ${item.tagName} has ${qualifier} focus indicator`,
+          ordinalSeverity: issueName === 'nonOutlinePresent' ? 2 : 3,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: item.text
+        });
+      });
+    });
+  }
+  else if (types.nonOutlinePresent.total || types.indicatorMissing.total) {
+    standardInstances.push({
+      issueID: 'focInd',
+      what: 'Elements have missing or non-outline focus indicators',
+      ordinalSeverity: types.indicatorMissing.total ? 3 : 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  // Reload the page.
+  await page.reload({timeout: 15000});
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/focOp.js

@@ -85,7 +85,7 @@ exports.reporter = async (page, withItems) => {
           id: id || '',
           text: (element.textContent.trim() || element.outerHTML.trim())
           .replace(/\s{2,}/sg, ' ')
-          .slice(0, 80)
+          .slice(0, 100)
         };
         if (status !== 'f') {
           elementData.byTag = byTag;
@@ -134,5 +134,64 @@ exports.reporter = async (page, withItems) => {
     console.log(`ERROR getting focOp data (${error.message})`);
     data.prevented = true;
   });
-  return {result: data};
+  // Derive the standard data.
+  const totals = [0, 0, 0, 0];
+  if (
+    data.totals
+    && data.totals.types
+    && data.totals.types.onlyFocusable
+    && data.totals.types.onlyOperable
+    && typeof data.totals.types.onlyFocusable.total === 'number'
+    && typeof data.totals.types.onlyOperable.total === 'number'
+  ) {
+    totals[2] = data.totals.types.onlyFocusable.total;
+    totals[3] = data.totals.types.onlyOperable.total;
+  }
+  const standardInstances = [];
+  if (data.items && data.items.onlyFocusable && data.items.onlyOperable) {
+    ['onlyFocusable', 'onlyOperable'].forEach(issue => {
+      const issueID = issue === 'onlyFocusable'
+        ? 'focOp-focusable-inoperable'
+        : 'focOp-operable-nonfocusable';
+      const gripe = issue === 'onlyFocusable'
+        ? 'is focusable but not operable'
+        : 'is operable but not focusable';
+      const ordinalSeverity = issue === 'onlyFocusable' ? 2 : 3;
+      data.items[issue].forEach(item => {
+        const itemID = item.id ? ` (ID ${item.id})` : '';
+        const which = `${item.tagName}${itemID}`;
+        standardInstances.push({
+          issueID,
+          what: `Element ${which} ${gripe}`,
+          ordinalSeverity,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: item.text
+        });
+      });
+    });
+  }
+  else if (totals[2] || totals[3]) {
+    standardInstances.push({
+      issueID: 'focOp',
+      what: 'Focusable elements are inoperable or vice versa',
+      ordinalSeverity: totals[3] ? 3 : 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  // Reload the page.
+  await page.reload({timeout: 15000});
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/focVis.js

@@ -25,5 +25,39 @@ exports.reporter = async (page, withItems) => {
   if (withItems) {
     data.items = badLinks;
   }
-  return {result: data};
+  const totals = [0, 0, data.total, 0];
+  const standardInstances = [];
+  if (data.items) {
+    data.items.forEach(item => {
+      standardInstances.push({
+        issueID: 'focVis',
+        what: 'Visible link is above or to the left of the display',
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: item
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'focVis',
+      what: 'Visible links are above or to the left of the display',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/hover.js

@@ -43,7 +43,7 @@ const samProb = (index, popSize, sampleRatio) =>
 const getSample = (population, sampleSize) => {
   const popSize = population.length;
   // If the sample is at least as large as the population:
-  if (sampleSize >= popSize) {
+  if (sampleSize >= popSize || sampleSize < 0) {
     // Return the population as the sample.
     return population.map(trigger => [trigger, 1]);
   }
@@ -181,7 +181,7 @@ const find = async (data, withItems, page, sample) => {
         const itemData = {
           tagName,
           id: (await firstTrigger[0].getAttribute('id')) || '',
-          text: await textOf(firstTrigger[0], 50)
+          text: await textOf(firstTrigger[0], 100)
         };
         try {
           // Hover over the trigger.
@@ -269,7 +269,7 @@ const find = async (data, withItems, page, sample) => {
                 // Add them to the data.
                 data.items.impactTriggers.push({
                   tagName,
-                  text: await textOf(firstTrigger[0], 50),
+                  text: await textOf(firstTrigger[0], 100),
                   additions,
                   removals,
                   opacityChanges,
@@ -309,7 +309,7 @@ const find = async (data, withItems, page, sample) => {
   }
 };
 // Performs the hover test and reports results.
-exports.reporter = async (page, sampleSize = -1, withItems) => {
+exports.reporter = async (page, withItems, sampleSize = -1) => {
   // Initialize the result.
   let data = {
     totals: {
@@ -376,6 +376,68 @@ exports.reporter = async (page, sampleSize = -1, withItems) => {
       data.totals[key] = Math.round(data.totals[key]);
     });
   }
+  const severity = {
+    impactTriggers: 3,
+    additions: 1,
+    removals: 2,
+    opacityChanges: 1,
+    opacityImpact: 0,
+    unhoverables: 3,
+    noCursors: 3,
+    badCursors: 2,
+    noIndicators: 3,
+    badIndicators: 2
+  };
+  const what = {
+    impactTriggers: 'Hovering over element has unexpected effects',
+    unhoverables: 'Operable element cannot be hovered over',
+    noCursors: 'Hoverable element hides the mouse cursor',
+    badCursors: 'Link or button makes the hovering mouse cursor nonstandard',
+    noIndicators: 'Button shows no indication of being hovered over',
+    badIndicators: 'List item changes when hovered over'
+  };
+  const totals = [0, 0, 0, 0];
+  Object.keys(data.totals).forEach(issue => {
+    totals[severity[issue]] += data.totals[issue];
+  });
+  const standardInstances = [];
+  if (data.items) {
+    Object.keys(data.items).forEach(issue => {
+      data.items[issue].forEach(item => {
+        const itemID = item.id ? ` (ID ${item.id})` : '';
+        standardInstances.push({
+          issueID: `hover-${issue}`,
+          what: what[issue],
+          ordinalSeverity: severity[issue],
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: `${itemID}: ${item.text}`
+        });
+      });
+    });
+  }
+  else if (totals.some(total => total)) {
+    standardInstances.push({
+      issueID: 'hover',
+      what: 'Hovering has unexpected impacts',
+      ordinalSeverity: totals.reduce((max, current, index) => current ? index : max, 0),
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  // Reload the page.
+  await page.reload({timeout: 15000});
   // Return the result.
-  return {result: data};
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/labClash.js

@@ -8,7 +8,7 @@
 exports.reporter = async (page, withItems) => {
   return await page.$eval('body', (body, withItems) => {
     // FUNCTION DEFINITION START
-    const debloat = text => text.replace(/\s+/g, ' ').trim();
+    const debloat = text => text ? text.replace(/\s+/g, ' ').trim().slice(0, 100) : '';
     // FUNCTION DEFINITION END
     // Initialize a report.
     const data = {
@@ -125,7 +125,7 @@ exports.reporter = async (page, withItems) => {
             labelee.tagName === 'BUTTON'
             || (labelee.tagName === 'INPUT' && labelee.type === 'submit')
           ) {
-            item.content = texts.content || `{${debloat(labelee.outerHTML)}}`;
+            item.content = debloat(texts.content) || debloat(labelee.outerHTML);
           }
           data.items.unlabeled.push(item);
         }
@@ -146,7 +146,53 @@ exports.reporter = async (page, withItems) => {
         }
       }
     });
-    return {result: data};
+    const totals = [0, 0, data.totals.mislabeled, data.totals.unlabeled];
+    const standardInstances = [];
+    if (data.items) {
+      ['mislabeled', 'unlabeled'].forEach(issue => {
+        let diagnosis;
+        let excerptTail;
+        data.items[issue].forEach(item => {
+          if (issue === 'mislabeled') {
+            diagnosis = `has clashing labels of types: ${item.labelTypes.join(', ')}`;
+            excerptTail = debloat(Object.values(item.texts).join(' '));
+          }
+          else {
+            diagnosis = 'is unlabeled';
+            excerptTail = item.content || '';
+          }
+          standardInstances.push({
+            issueID: `labClash-${issue}`,
+            what: `Element ${item.tagName} ${diagnosis}`,
+            ordinalSeverity: issue === 'mislabeled' ? 2 : 3,
+            location: {
+              doc: '',
+              type: '',
+              spec: ''
+            },
+            excerpt: `${item.tagName}: ${excerptTail}`
+          });
+        });
+      });
+    }
+    else if (data.totals.mislabeled || data.totals.unlabeled) {
+      standardInstances.push({
+        issueID: 'labClash',
+        what: 'Element labels are conflicting or missing',
+        ordinalSeverity: data.totals.unlabeled ? 3 : 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      });
+    }
+    return {
+      data,
+      totals,
+      standardInstances
+    };
   }, withItems)
   .catch(error => {
     console.log(`ERROR: labClash failed (${error.message})`);
@@ -154,6 +200,10 @@ exports.reporter = async (page, withItems) => {
       prevented: true,
       error: 'ERROR: labClash failed'
     };
-    return {result: data};
+    return {
+      data,
+      totals: [],
+      standardInstances: []
+    };
   });
 };

package/{tests → testaro}/linkTo.js

@@ -18,8 +18,40 @@ exports.reporter = async (page, withItems) => {
   const data = {
     total: badLinkTexts.length
   };
+  const totals = [0, 0, data.total, 0];
+  const standardInstances = [];
   if (withItems) {
     data.items = badLinkTexts;
+    data.items.forEach(item => {
+      standardInstances.push({
+        issueID: 'linkTo',
+        what: 'Element a has no href attribute',
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: item
+      });
+    });
   }
-  return {result: data};
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'linkTo',
+      what: 'Links are missing href attributes',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
+  }
+  return {
+    data,
+    totals,
+    standardInstances
+  };
 };

package/{tests → testaro}/linkUl.js

@@ -16,7 +16,10 @@ exports.reporter = async (page, withItems) => {
     const linkTypes = args[1];
     // FUNCTION DEFINITION START
     // Returns a space-minimized copy of a string.
-    const compact = string => string.replace(/[\t\n]/g, '').replace(/\s{2,}/g, ' ').trim();
+    const compact = string => string
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 100);
     // FUNCTION DEFINITION END
     // Identify the adjacent links.
     const adjacentLinks = linkTypes.adjacent;
@@ -27,7 +30,7 @@ exports.reporter = async (page, withItems) => {
     // For each of them:
     adjacentLinks.forEach(link => {
       // Identify the text of the link if itemization is required.
-      const text = withItems ? compact(link.textContent) : '';
+      const text = withItems ? compact(link.textContent) || compact(link.outerHTML) : '';
       // If it is underlined:
       if (window.getComputedStyle(link).textDecorationLine === 'underline') {
         // Increment the count of underlined inline links.
@@ -45,8 +48,8 @@ exports.reporter = async (page, withItems) => {
     });
     // Get the percentage of underlined links among all inline links.
     const underlinedPercent = adjacentLinkCount
-    ? Math.floor(100 * underlined / adjacentLinkCount)
-    : 'N/A';
+      ? Math.floor(100 * underlined / adjacentLinkCount)
+      : 'N/A';
     const data = {
       totals: {
         links: adjacentLinks.length + linkTypes.list.length,
@@ -63,6 +66,41 @@ exports.reporter = async (page, withItems) => {
         notUnderlined: nulAdjacentLinkTexts
       };
     }
-    return {result: data};
+    const {adjacent} = data.totals;
+    const totals = [0, adjacent.total - adjacent.underlined, 0, 0];
+    const standardInstances = [];
+    if (data.items && data.items.notUnderlined) {
+      data.items.notUnderlined.forEach(item => {
+        standardInstances.push({
+          issueID: 'linkUl',
+          what: 'Element a is inline but has no underline',
+          ordinalSeverity: 1,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: item
+        });
+      });
+    }
+    else if (adjacent.total - adjacent.underlined > 0) {
+      standardInstances.push({
+        issueID: 'linkUl',
+        what: 'Inline links are missing underlines',
+        ordinalSeverity: 1,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      });
+    }
+    return {
+      data,
+      totals,
+      standardInstances
+    };
   }, [withItems, linkTypes]);
 };

package/{tests → testaro}/menuNav.js

@@ -260,5 +260,46 @@ exports.reporter = async (page, withItems) => {
     // FUNCTION DEFINITIONS END
     await testMenus(menus);
   }
-  return {result: data};
+  const totals = data.totals ? [
+    data.totals.navigations.all.incorrect,
+    data.totals.menuItems.incorrect,
+    data.totals.menus.incorrect,
+    0
+  ] : [];
+  const standardInstances = [];
+  if (data.menuItems && data.menuItems.incorrect) {
+    data.menuItems.incorrect.forEach(item => {
+      standardInstances.push({
+        issueID: 'menuNav',
+        what: `Element ${item.tagName} is a menu item but has nonstandard navigation`,
+        ordinalSeverity: 1,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: `${item.tagName}: ${item.text}`
+      });
+    });
+  }
+  else if (data.totals.menuItems.incorrect) {
+    standardInstances.push({
+      issueID: 'menuNav',
+      what: 'Menus and menu items 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}/miniText.js

@@ -41,8 +41,39 @@ exports.reporter = async (page, withItems) => {
   const data = {
     total: miniTexts.length
   };
+  const standardInstances = [];
   if (withItems) {
     data.items = miniTexts;
+    miniTexts.forEach(text => {
+      standardInstances.push({
+        issueID: 'miniText',
+        what: 'Text font is smaller than 11 pixels',
+        ordinalSeverity: 2,
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: text
+      });
+    });
+  }
+  else if (data.total) {
+    standardInstances.push({
+      issueID: 'miniText',
+      what: 'Texts have fonts smaller than 11 pixels',
+      ordinalSeverity: 2,
+      location: {
+        doc: '',
+        type: '',
+        spec: ''
+      },
+      excerpt: ''
+    });
   }
-  return {result: data};
+  return {
+    data,
+    totals: [0, 0, data.total, 0],
+    standardInstances
+  };
 };