testaro 5.11.4 → 5.12.2

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-insensitive substring of the text node']
+      }
+    ],
     titledEl: [
       'Perform a titledEl test',
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "5.11.4",
+  "version": "5.12.2",
   "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',
@@ -685,7 +687,7 @@ const doActs = async (report, actIndex, page) => {
             }
             catch(error) {
               actIndex = -2;
-              waitError(page, act, error, 'URL');
+              waitError(page, act, error, 'text in the URL');
             }
           }
           // Otherwise, if the text is to be a substring of the page title:
@@ -707,7 +709,7 @@ const doActs = async (report, actIndex, page) => {
             }
             catch(error) {
               actIndex = -2;
-              waitError(page, act, error, 'title');
+              waitError(page, act, error, 'text in the title');
             }
           }
           // Otherwise, if the text is to be a substring of the text of the page body:
@@ -721,14 +723,14 @@ const doActs = async (report, actIndex, page) => {
                 which,
                 {
                   polling: 2000,
-                  timeout: 10000
+                  timeout: 15000
                 }
               );
               result.found = true;
             }
             catch(error) {
               actIndex = -2;
-              waitError(page, act, error, 'body');
+              waitError(page, act, error, 'text in the body');
             }
           }
         }
@@ -948,77 +950,71 @@ const doActs = async (report, actIndex, page) => {
               act.result = {found: false};
               let selection = {};
               let tries = 0;
-              const slimText = debloat(act.which);
+              const slimText = act.which ? debloat(act.which) : '';
               while (tries++ < 5 && ! act.result.found) {
-                if (act.which) {
-                  // If the page still exists:
-                  if (page) {
-                    // Identify the elements of the specified type.
-                    const selections = await page.$$(selector);
-                    // If there are any:
-                    if (selections.length) {
-                      // If there are enough to make a match possible:
-                      if ((act.index || 0) < selections.length) {
-                        // For each element of the specified type:
-                        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);
-                          selectionTexts.push(selectionText);
-                          // If its text includes the specified text:
-                          if (selectionText.includes(slimText)) {
-                            // If the element has the specified index among such elements:
-                            if (matchCount++ === (act.index || 0)) {
-                              // Report it as the matching element and stop checking.
-                              act.result.found = true;
-                              act.result.text = slimText;
-                              break;
-                            }
+                // If the page still exists:
+                if (page) {
+                  // Identify the elements of the specified type.
+                  const selections = await page.$$(selector);
+                  // If there are any:
+                  if (selections.length) {
+                    // If there are enough to make a match possible:
+                    if ((act.index || 0) < selections.length) {
+                      // For each element of the specified type:
+                      let matchCount = 0;
+                      const selectionTexts = [];
+                      for (selection of selections) {
+                        // 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 any specified text:
+                        if (selectionText.includes(slimText)) {
+                          // If the element has the specified index among such elements:
+                          if (matchCount++ === (act.index || 0)) {
+                            // Report it as the matching element and stop checking.
+                            act.result.found = true;
+                            act.result.text = slimText;
+                            break;
                           }
                         }
-                        // If no element satisfied the specifications:
-                        if (! act.result.found) {
-                          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';
-                          act.result.candidateTexts = selectionTexts;
-                        }
                       }
-                      // Otherwise, i.e. if there are too few such elements to make a match possible:
-                      else {
-                        // Return a failure.
+                      // If no element satisfied the specifications:
+                      if (! act.result.found) {
+                        // Add the failure data to the report.
                         act.result.success = false;
-                        act.result.error = 'fewer';
+                        act.result.error = 'exhausted';
                         act.result.typeElementCount = selections.length;
-                        act.result.message = 'Elements of specified type too few';
+                        if (slimText) {
+                          act.result.textElementCount = --matchCount;
+                        }
+                        act.result.message = 'Not enough specified elements exist';
+                        act.result.candidateTexts = selectionTexts;
                       }
                     }
-                    // Otherwise, i.e. if there are no elements of the specified type:
+                    // 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 = 'none';
-                      act.result.typeElementCount = 0;
-                      act.result.message = 'No elements specified type found';
+                      act.result.error = 'fewer';
+                      act.result.typeElementCount = selections.length;
+                      act.result.message = 'Elements of specified type too few';
                     }
                   }
-                  // Otherwise, i.e. if the page no longer exists:
+                  // 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 = 'gone';
-                    act.result.message = 'Page gone';
+                    act.result.error = 'none';
+                    act.result.typeElementCount = 0;
+                    act.result.message = 'No elements of specified type found';
                   }
                 }
-                // Otherwise, i.e. if no text was specified:
+                // 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 = 'text';
-                  act.result.message = 'No text specified';
+                  act.result.error = 'gone';
+                  act.result.message = 'Page gone';
                 }
                 if (! act.result.found) {
                   await wait(2000);
@@ -1026,6 +1022,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: 15000}),
+                      actionIsClick ? selection.click({timeout: 4000}) : selection.press('Enter')
+                    ]);
+                    // Wait for the new page to load.
+                    await newPage.waitForLoadState('domcontentloaded', {timeout: 15000});
+                    // 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 +1106,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: 7000}),
-                        selection.click({timeout: 4000})
-                      ]);
-                      // 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 {
@@ -1157,8 +1160,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 +1175,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,142 @@
+/*
+  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();
+      // Make a copy of the body.
+      const tempBody = document.body.cloneNode(true);
+      // Insert it into the document.
+      document.body.appendChild(tempBody);
+      // Remove the irrelevant text content from the copy.
+      const extraElements = Array.from(tempBody.querySelectorAll('style, script, svg'));
+      extraElements.forEach(element => {
+        element.textContent = '';
+      });
+      // 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 (! ['STYLE', 'SCRIPT', 'SVG', 'svg'].includes(element.tagName)) {
+          if (withText) {
+            data.text = compact(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 && labels.length) {
+            data.labels = Array.from(labels).map(label => compact(label.textContent));
+          }
+          // Add data on its child elements, if any, to the data.
+          if (element.childElementCount) {
+            const children = Array.from(element.children);
+            data.children = [];
+            children.forEach(child => {
+              data.children.push(getElementData(child, true));
+            });
+          }
+        }
+        return data;
+      };
+      // FUNCTION DEFINITIONS END
+      const normText = normalize(text);
+      // Create a collection of the text nodes.
+      const walker = document.createTreeWalker(tempBody, 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)) {
+            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);
+        });
+      }
+      document.body.removeChild(tempBody);
+      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};
+};