testaro 5.11.2 → 5.12.0

package/commands.js

@@ -3,7 +3,7 @@ exports.commands = {
     button: [
       'Click a button or submit input',
       {
-        which: [true, 'string', 'hasLength', 'substring of button text'],
+        which: [false, 'string', 'hasLength', 'substring of button text'],
         index: [false, 'number', '', 'index among matches if not 0'],
         what: [false, 'string', 'hasLength', 'comment']
       }
@@ -21,7 +21,7 @@ exports.commands = {
       {
         what: [true, 'string', 'isFocusable', 'selector of element to be focused'],
         index: [false, 'number', '', 'index among matches if not 0'],
-        which: [true, 'string', 'hasLength', 'substring of element text']
+        which: [false, 'string', 'hasLength', 'substring of element text']
       }
     ],
     launch: [
@@ -34,7 +34,7 @@ exports.commands = {
     link: [
       'Click a link and wait for the page to be idle or loaded',
       {
-        which: [true, 'string', 'hasLength', 'substring of link text'],
+        which: [false, 'string', 'hasLength', 'substring of link text'],
         index: [false, 'number', '', 'index among matches if not 0'],
         what: [false, 'string', 'hasLength', 'comment']
       }
@@ -89,10 +89,18 @@ exports.commands = {
         what: [false, 'string', 'hasLength', 'comment']
       }
     ],
+    search: [
+      'Enter text into a search input, optionally with 1 placeholder for an all-caps literal environment variable',
+      {
+        which: [false, 'string', 'hasLength', 'substring of input text'],
+        index: [false, 'number', '', 'index among matches if not 0'],
+        what: [true, 'string', 'hasLength', 'text to enter, with optional __PLACEHOLDER__']
+      }
+    ],
     select: [
       'Select a select option',
       {
-        which: [true, 'string', 'hasLength', 'substring of select-list text'],
+        which: [false, 'string', 'hasLength', 'substring of select-list text'],
         index: [false, 'number', '', 'index among matches if not 0'],
         what: [true, 'string', 'hasLength', 'substring of option text content']
       }
@@ -122,7 +130,7 @@ exports.commands = {
     text: [
       'Enter text into a text input, optionally with 1 placeholder for an all-caps literal environment variable',
       {
-        which: [true, 'string', 'hasLength', 'substring of input text'],
+        which: [false, 'string', 'hasLength', 'substring of input text'],
         index: [false, 'number', '', 'index among matches if not 0'],
         what: [true, 'string', 'hasLength', 'text to enter, with optional __PLACEHOLDER__']
       }
@@ -154,9 +162,9 @@ exports.commands = {
       'Perform an elements test',
       {
         detailLevel: [true, 'number', '', '0 to 3, to specify the level of detail'],
-        tagName: [false, 'string', '', 'tag name of elements'],
+        tagName: [false, 'string', 'hasLength', 'tag name of elements'],
         onlyVisible: [false, 'boolean', '', 'whether to exclude invisible elements'],
-        attribute: [false, 'string', 'hasLength', 'required attribute or attribute=value']
+        attribute: [false, 'string', 'hasLength', 'required attribute selector']
       }
     ],
     embAc: [
@@ -273,6 +281,13 @@ exports.commands = {
         id: [true, 'string', 'hasLength', 'ID of the requested test instance']
       }
     ],
+    textNodes: [
+      'Perform a textNodes test',
+      {
+        detailLevel: [true, 'number', '', '0 to 3, to specify the level of detail'],
+        text: [false, 'string', 'hasLength', 'case-insensiteve substring of the text node']
+      }
+    ],
     titledEl: [
       'Perform a titledEl test',
       {

package/package.json

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

package/run.js

@@ -24,6 +24,7 @@ const moves = {
   focus: true,
   link: 'a, [role=link]',
   radio: 'input[type=radio]',
+  search: 'input[type=search]',
   select: 'select',
   text: 'input[type=text]'
 };
@@ -56,6 +57,7 @@ const tests = {
   styleDiff: 'style inconsistencies',
   tabNav: 'keyboard navigation between tab elements',
   tenon: 'Tenon',
+  textNodes: 'data on specified text nodes',
   title: 'page title',
   titledEl: 'title attributes on inappropriate elements',
   wave: 'WAVE',
@@ -963,10 +965,10 @@ const doActs = async (report, actIndex, page) => {
                         let matchCount = 0;
                         const selectionTexts = [];
                         for (selection of selections) {
-                          // Add its text to the list of texts of such elements.
-                          const selectionText = await textOf(page, selection);
+                          // Add its text or an empty string to the list of texts of such elements.
+                          const selectionText = slimText ? await textOf(page, selection) : '';
                           selectionTexts.push(selectionText);
-                          // If its text includes the specified text:
+                          // If its text includes any specified text:
                           if (selectionText.includes(slimText)) {
                             // If the element has the specified index among such elements:
                             if (matchCount++ === (act.index || 0)) {
@@ -979,17 +981,20 @@ const doActs = async (report, actIndex, page) => {
                         }
                         // If no element satisfied the specifications:
                         if (! act.result.found) {
+                          // Add the failure data to the report.
                           act.result.success = false;
                           act.result.error = 'exhausted';
                           act.result.typeElementCount = selections.length;
-                          act.result.textElementCount = --matchCount;
-                          act.result.message = 'Not enough elements have the specified text';
+                          if (slimText) {
+                            act.result.textElementCount = --matchCount;
+                          }
+                          act.result.message = 'Not enough specified elements exist';
                           act.result.candidateTexts = selectionTexts;
                         }
                       }
                       // Otherwise, i.e. if there are too few such elements to make a match possible:
                       else {
-                        // Return a failure.
+                        // Add the failure data to the report.
                         act.result.success = false;
                         act.result.error = 'fewer';
                         act.result.typeElementCount = selections.length;
@@ -998,16 +1003,16 @@ const doActs = async (report, actIndex, page) => {
                     }
                     // Otherwise, i.e. if there are no elements of the specified type:
                     else {
-                      // Return a failure.
+                      // Add the failure data to the report.
                       act.result.success = false;
                       act.result.error = 'none';
                       act.result.typeElementCount = 0;
-                      act.result.message = 'No elements specified type found';
+                      act.result.message = 'No elements of specified type found';
                     }
                   }
                   // Otherwise, i.e. if the page no longer exists:
                   else {
-                    // Return a failure.
+                    // Add the failure data to the report.
                     act.result.success = false;
                     act.result.error = 'gone';
                     act.result.message = 'Page gone';
@@ -1015,7 +1020,7 @@ const doActs = async (report, actIndex, page) => {
                 }
                 // Otherwise, i.e. if no text was specified:
                 else {
-                  // Return a failure.
+                  // Add the failure data to the report.
                   act.result.success = false;
                   act.result.error = 'text';
                   act.result.message = 'No text specified';
@@ -1026,6 +1031,36 @@ const doActs = async (report, actIndex, page) => {
               }
               // If a match was found:
               if (act.result.found) {
+                // FUNCTION DEFINITION START
+                // Perform a click or Enter keypress and wait for a page load.
+                const doAndWait = async actionIsClick => {
+                  try {
+                    const [newPage] = await Promise.all([
+                      page.context().waitForEvent('page', {timeout: 7000}),
+                      actionIsClick ? selection.click({timeout: 4000}) : selection.press('Enter')
+                    ]);
+                    // Wait for the new page to load.
+                    await newPage.waitForLoadState('domcontentloaded', {timeout: 10000});
+                    // Make the new page the current page.
+                    page = newPage;
+                    act.result.success = true;
+                    act.result.move = actionIsClick ? 'clicked' : 'Enter pressed';
+                    act.result.newURL = page.url();
+                  }
+                  // If the action, event, or load failed:
+                  catch(error) {
+                    // Quit and report the failure.
+                    const action = actionIsClick ? 'clicking' : 'pressing Enter';
+                    console.log(
+                      `ERROR ${action} (${error.message.replace(/\n.+/s, '')})`
+                    );
+                    act.result.success = false;
+                    act.result.error = 'moveFailure';
+                    act.result.message = 'ERROR: move, navigation, or load timed out';
+                    actIndex = -2;
+                  }
+                };
+                // FUNCTION DEFINITION END
                 // If the move is a button click, perform it.
                 if (act.type === 'button') {
                   await selection.click({timeout: 3000});
@@ -1080,30 +1115,7 @@ const doActs = async (report, actIndex, page) => {
                   // If the destination is a new page:
                   if (target && target !== '_self') {
                     // Click the link and wait for the resulting page event.
-                    try {
-                      const [newPage] = await Promise.all([
-                        page.context().waitForEvent('page', {timeout: 6000}),
-                        selection.click({timeout: 5000})
-                      ]);
-                      // Wait for the new page to load.
-                      await newPage.waitForLoadState('domcontentloaded', {timeout: 10000});
-                      // Make the new page the current page.
-                      page = newPage;
-                      act.result.success = true;
-                      act.result.move = 'clicked';
-                      act.result.newURL = page.url();
-                    }
-                    // If the click, event, or load failed:
-                    catch(error) {
-                      // Quit and report the failure.
-                      console.log(
-                        `ERROR clicking new-page link (${error.message.replace(/\n.+/s, '')})`
-                      );
-                      act.result.success = false;
-                      act.result.error = 'unclickable';
-                      act.result.message = 'ERROR: click, navigation, or load timed out';
-                      actIndex = -2;
-                    }
+                    doAndWait(true);
                   }
                   // Otherwise, i.e. if the destination is in the current page:
                   else {
@@ -1111,7 +1123,7 @@ const doActs = async (report, actIndex, page) => {
                     try {
                       await selection.click({timeout: 5000});
                       // Wait for the new content to load.
-                      await page.waitForLoadState('domcontentloaded', {timeout: 4000});
+                      await page.waitForLoadState('domcontentloaded', {timeout: 6000});
                       act.result.success = true;
                       act.result.move = 'clicked';
                       act.result.newURL = page.url();
@@ -1157,8 +1169,8 @@ const doActs = async (report, actIndex, page) => {
                   act.result.move = 'selected';
                   act.result.option = optionText;
                 }
-                // Otherwise, if it is entering text on the element:
-                else if (act.type === 'text') {
+                // Otherwise, if it is entering text on a text- or search-input element:
+                else if (['text', 'search'].includes(act.type)) {
                   // If the text contains a placeholder for an environment variable:
                   let {what} = act;
                   if (/__[A-Z]+__/.test(what)) {
@@ -1172,6 +1184,11 @@ const doActs = async (report, actIndex, page) => {
                   report.presses += act.what.length;
                   act.result.success = true;
                   act.result.move = 'entered';
+                  // If the input is a search input:
+                  if (act.type === 'search') {
+                    // Press the Enter key and wait for a new page to load.
+                    doAndWait(false);
+                  }
                 }
                 // Otherwise, i.e. if the move is unknown, add the failure to the act.
                 else {

package/tests/elements.js

@@ -23,13 +23,20 @@ exports.reporter = async (page, detailLevel, tagName, onlyVisible, attribute) =>
       // FUNCTION DEFINITIONS START
       // Compacts a string.
       const compact = string => string.replace(/\s+/g, ' ').trim();
-      // Gets data on the sibling nodes of an element.
+      // Gets data on a sibling node of an element.
       const getSibInfo = (node, nodeType, text) => {
         const sibInfo = {
           type: nodeType
         };
         if (nodeType === 1) {
           sibInfo.tagName = node.tagName;
+          sibInfo.attributes = [];
+          node.attributes.forEach(attribute => {
+            sibInfo.attributes.push({
+              name: attribute.name,
+              value: attribute.value
+            });
+          });
         }
         else if (nodeType === 3) {
           sibInfo.text = compact(text);

package/tests/textNodes.js

@@ -0,0 +1,125 @@
+/*
+  textNodes
+  This test reports data about specified text nodes.
+  Meanings of detailLevel values:
+    0. Only total node count; no detail.
+    1+. Count of ancestry levels to provide data on (1 = text node, 2 = also parent, etc.)
+*/
+exports.reporter = async (page, detailLevel, text) => {
+  let data = {};
+  // Get the data on the text nodes.
+  try {
+    data = await page.evaluate(args => {
+      const detailLevel = args[0];
+      const text = args[1];
+      const matchNodes = [];
+      // Normalize the body.
+      document.body.normalize();
+      // FUNCTION DEFINITIONS START
+      // Compacts a string.
+      const compact = string => string.replace(/\s+/g, ' ').trim();
+      // Compacts and lower-cases a string.
+      const normalize = string => compact(string).toLowerCase();
+      // Gets data on an element.
+      const getElementData = (element, withText) => {
+        // Initialize the data.
+        const data = {
+          tagName: element.tagName
+        };
+        if (withText) {
+          data.text = element.textContent;
+        }
+        // Add data on its attributes, if any, to the data.
+        const {attributes} = element;
+        if (attributes) {
+          data.attributes = [];
+          for (const attribute of attributes) {
+            const {name, value} = attribute;
+            data.attributes.push({
+              name,
+              value
+            });
+            // If any attribute is a labeler reference:
+            if (name === 'aria-labelledby') {
+              // Add the label texts to the data.
+              const labelerIDs = value.split(/\s+/);
+              data.refLabels = [];
+              labelerIDs.forEach(id => {
+                const labeler = document.getElementById(id);
+                if (labeler) {
+                  data.refLabels.push(compact(labeler.textContent));
+                }
+              });
+            }
+          }
+        }
+        // Add data on its labels, if any, to the data.
+        const {labels} = element;
+        if (labels) {
+          data.labels = Array.from(labels).map(label => compact(label.textContent));
+        }
+        return data;
+      };
+      // FUNCTION DEFINITIONS END
+      const normText = normalize(text);
+      // Create a collection of the text nodes.
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+      // Get their count.
+      const data = {nodeCount: 0};
+      let more = true;
+      while(more) {
+        if (walker.nextNode()) {
+          if (
+            normalize(walker.currentNode.nodeValue).includes(normText)
+            && walker.currentNode.parentElement.tagName !== 'SCRIPT'
+          ) {
+            data.nodeCount++;
+            matchNodes.push(walker.currentNode);
+          }
+        }
+        else {
+          more = false;
+        }
+      }
+      // If no itemization is required:
+      if (detailLevel === 0) {
+        // Return the node count.
+        return data;
+      }
+      // Otherwise, i.e. if itemization is required:
+      else {
+        // Initialize the item data.
+        data.items = [];
+        // For each text node matching the specified text:
+        matchNodes.forEach(node => {
+          // Initialize the data on it.
+          const itemData = {text: compact(node.nodeValue)};
+          // If ancestral itemization is required:
+          if (detailLevel > 1) {
+            // Add the ancestral data to the item data.
+            itemData.ancestors = [];
+            let base = node;
+            let currentLevel = 1;
+            while(currentLevel++ < detailLevel) {
+              const newBase = base.parentElement;
+              itemData.ancestors.push(getElementData(newBase, currentLevel > 2));
+              base = newBase;
+            }
+          }
+          // Add the node data to the itemization.
+          data.items.push(itemData);
+        });
+      }
+      return data;
+    }, [detailLevel, text]);
+  }
+  catch(error) {
+    console.log(`ERROR performing test (${error.message.replace(/\n.+/s, '')})`);
+    data = {
+      prevented: true,
+      error: 'ERROR performing test'
+    };
+  }
+  // Return the result.
+  return {result: data};
+};

package/tests/title.js

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