testaro 14.11.0 → 14.13.0

package/package.json

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

package/testaro/filter.js

@@ -63,7 +63,7 @@ exports.reporter = async (page, withItems) => {
           type: '',
           spec: ''
         },
-        excerpt: `${item.tagName}: ${item.text}`
+        excerpt: item.text.slice(0, 200)
       });
     });
   }

package/testaro/focOp.js

@@ -10,9 +10,12 @@
   operable, users are likely to be surprised that nothing happens when they try to operate such
   elements. If operable elements are not focusable, users depending on keyboard navigation are
   prevented from operating those elements. The test considers an element operable if it has a
-  non-inherited pointer cursor and is not a 'LABEL' element, or has an operable tag name ('A',
-  'BUTTON', 'IFRAME', 'INPUT', 'SELECT', 'TEXTAREA'), or has an 'onclick' attribute. The test
-  considers an element Tab-focusable if its tabIndex property has the value 0.
+  non-inherited pointer cursor and is not a 'LABEL' element, has an operable tag name ('A',
+  'BUTTON', 'IFRAME', 'INPUT', 'SELECT', 'TEXTAREA'), has an interactive explicit role (button,
+  link, checkbox, switch, input, textbox, searchbox, combobox, option, treeitem, radio, slider,
+  spinbutton, menuitem, menuitemcheckbox, composite, grid, select, listbox, menu, menubar, tree,
+  tablist, tab, gridcell, radiogroup, treegrid, widget, or scrollbar), or has an 'onclick'
+  attribute. The test considers an element Tab-focusable if its tabIndex property has the value 0.
 */
 exports.reporter = async (page, withItems) => {
   // Get data on focusability-operability-discrepant elements.
@@ -29,10 +32,6 @@ exports.reporter = async (page, withItems) => {
           onlyOperable: {
             total: 0,
             tagNames: {}
-          },
-          focusableAndOperable: {
-            total: 0,
-            tagNames: {}
           }
         }
       }
@@ -40,22 +39,59 @@ exports.reporter = async (page, withItems) => {
     if (withItems) {
       data.items = {
         onlyFocusable: [],
-        onlyOperable: [],
-        focusableAndOperable: []
+        onlyOperable: []
       };
     }
     // FUNCTION DEFINITIONS START
     // Returns data on an element’s operability and prevents it from propagating a pointer.
     const operabilityOf = element => {
+      // Identify the operable tag names.
       const opTags = new Set(['A', 'BUTTON', 'IFRAME', 'INPUT', 'SELECT', 'TEXTAREA']);
+      // Identify the operable roles.
+      const opRoles = new Set([
+        'button',
+        'checkbox',
+        'combobox',
+        'composite',
+        'grid',
+        'gridcell',
+        'input',
+        'link',
+        'listbox',
+        'menu',
+        'menubar',
+        'menuitem',
+        'menuitemcheckbox',
+        'option',
+        'radio',
+        'radiogroup',
+        'scrollbar',
+        'searchbox',
+        'select',
+        'slider',
+        'spinbutton',
+        'switch',
+        'tab',
+        'tablist',
+        'textbox',
+        'tree',
+        'treegrid',
+        'treeitem',
+        'widget',
+      ]);
+      // Identify whether the element has a pointer cursor.
       const hasPointer = window.getComputedStyle(element).cursor === 'pointer';
+      // Identify the bases for considering an element operable.
       const opBases = [
         opTags.has(element.tagName),
         element.hasAttribute('onclick'),
+        opRoles.has(element.getAttribute('role')),
         hasPointer && element.tagName !== 'LABEL'
       ];
+      // If the element is operable:
       const result = {operable: opBases.some(basis => basis)};
       if (result.operable) {
+        // Add its data to its result.
         result.byTag = opBases[0];
         result.byOnClick = opBases[1];
         result.byPointer = opBases[2];
@@ -65,14 +101,14 @@ exports.reporter = async (page, withItems) => {
         // Change it to the browser default to prevent pointer propagation.
         element.style.cursor = 'default';
       }
+      // Return the result.
       return result;
     };
     // Adds facts about an element to data.
     const addFacts = (element, status, byTag, byOnClick, byPointer) => {
       const statusNames = {
         f: 'onlyFocusable',
-        o: 'onlyOperable',
-        b: 'focusableAndOperable'
+        o: 'onlyOperable'
       };
       const statusName = statusNames[status];
       data.totals.types[statusName].total++;
@@ -100,17 +136,12 @@ exports.reporter = async (page, withItems) => {
     elements.forEach(element => {
       // If its tab index is 0, deem it focusable and:
       if (element.tabIndex === 0) {
-        // Increment the grand total.
-        data.totals.total++;
         // Determine whether and how it is operable.
-        const {operable, byTag, byOnClick, byPointer} = operabilityOf(element);
-        // If it is:
-        if (operable) {
-          // Add its data to the result.
-          addFacts(element, 'b', byTag, byOnClick, byPointer);
-        }
-        // Otherwise, i.e. if it is not operable:
-        else {
+        const {operable} = operabilityOf(element);
+        // If it is not:
+        if (! operable) {
+          // Increment the total.
+          data.totals.total++;
           // Add its data to the result.
           addFacts(element, 'f');
         }
@@ -121,7 +152,7 @@ exports.reporter = async (page, withItems) => {
         const {operable, byTag, byOnClick, byPointer} = operabilityOf(element);
         // If it is:
         if (operable) {
-          // Increment the grand total.
+          // Increment the total.
           data.totals.total++;
           // Add its data to the result.
           addFacts(element, 'o', byTag, byOnClick, byPointer);

package/testaro/pseudoP.js

@@ -0,0 +1,85 @@
+/*
+  pseudoP
+  This test reports 2 or more sequential br elements. They may be inferior substitutes for a
+  p element.
+*/
+// Runs the test and returns the results.
+exports.reporter = async (page, withItems) => {
+  // Identify the elements containing 2 or more consecutive br elements.
+  const data = await page.$$eval('br + br', br2s => {
+    // Returns a space-minimized copy of a string.
+    const compact = string => string
+    .replace(/[\t\n]/g, '')
+    .replace(/\s{2,}/g, ' ')
+    .trim()
+    .slice(0, 100);
+    // Initialize a set of the parent elements of successive br elements.
+    const dataSet = new Set([]);
+    // For each br element with an immediately preceding br sibling:
+    br2s.forEach(br2 => {
+      // Add it to the data.
+      const parent = br2.parentElement;
+      dataSet.add(parent);
+    });
+    // Initialize data on the parents.
+    const data = [];
+    dataSet.forEach(parent => {
+      data.push({
+        tagName: parent.tagName,
+        id: parent.id || '',
+        text: compact(parent.textContent)
+      });
+    });
+    return data;
+  });
+  // Initialize the standard result.
+  const totals = [data.length, 0, 0, 0];
+  // If there are any instances:
+  const standardInstances = [];
+  if (data.length) {
+    // If itemization is required:
+    if (withItems) {
+      // Add the instances to the standard result.
+      data.forEach(item => {
+        standardInstances.push({
+          ruleID: 'pseudoP',
+          what: `${item.tagName} element contains 2 or more adjacent br elements that may be nonsemantic substitute for a p element`,
+          ordinalSeverity: 0,
+          tagName: item.tagName.toUpperCase(),
+          id: item.id,
+          location: {
+            doc: '',
+            type: '',
+            spec: ''
+          },
+          excerpt: item.text.slice(0, 200)
+        });
+      });
+    }
+    // Otherwise, i.e. if itemization is not required:
+    else {
+      // Add a summary instance to the standard result.
+      standardInstances.push({
+        ruleID: 'pseudoP',
+        what: 'Elements contain 2 or more adjacent br elements that may be nonsemantic substitutes for p elements',
+        ordinalSeverity: 2,
+        count: data.length,
+        tagName: '',
+        id: '',
+        location: {
+          doc: '',
+          type: '',
+          spec: ''
+        },
+        excerpt: ''
+      });
+      data.length = 0;
+    }
+  }
+  // Return the result and the standard result.
+  return {
+    data,
+    totals,
+    standardInstances
+  };
+};

package/tests/testaro.js

@@ -27,6 +27,7 @@ const evalRules = {
   miniText: 'text smaller than 11 pixels',
   motion: 'motion without user request',
   nonTable: 'table elements used for layout',
+  pseudoP: 'adjacent br elements suspected of nonsemantically simulating p elements',
   radioSet: 'radio buttons not grouped into standard field sets',
   role: 'invalid and native-replacing explicit roles',
   styleDiff: 'style inconsistencies',