testaro 5.12.1 → 5.13.0

package/package.json

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

package/run.js

@@ -24,9 +24,9 @@ const moves = {
   focus: true,
   link: 'a, [role=link]',
   radio: 'input[type=radio]',
-  search: 'input[type=search]',
+  search: 'input[type=search], input[aria-label*=search i], input[placeholder*=search i]',
   select: 'select',
-  text: 'input[type=text]'
+  text: 'input[type=text], input:not([type])'
 };
 // Names and descriptions of tests.
 const tests = {
@@ -114,6 +114,7 @@ let actCount = 0;
 let browser;
 let browserContext;
 let browserTypeName;
+let currentPage;
 let requestedURL = '';
 
 // ########## VALIDATORS
@@ -273,6 +274,8 @@ const browserClose = async () => {
     await browser.close();
   }
 };
+// Returns the first line of an error message.
+const errorStart = error => error.message.replace(/\n.+/s, '');
 // Launches a browser.
 const launch = async typeName => {
   const browserType = require('playwright')[typeName];
@@ -292,15 +295,15 @@ const launch = async typeName => {
     browser = await browserType.launch(browserOptions)
     .catch(error => {
       healthy = false;
-      console.log(`ERROR launching browser: ${error.message.replace(/\n.+/s, '')}`);
+      console.log(`ERROR launching browser (${errorStart(error)})`);
     });
     // If the launch succeeded:
     if (healthy) {
       browserContext = await browser.newContext();
       // When a page (i.e. browser tab) is added to the browser context (i.e. browser window):
       browserContext.on('page', async page => {
-        // Activate the page.
-        await page.bringToFront();
+        // Make the page current.
+        currentPage = page;
         // Make abbreviations of its console messages get reported in the Playwright console.
         page.on('console', msg => {
           const msgText = msg.text();
@@ -335,11 +338,11 @@ const launch = async typeName => {
         });
       });
       // Open the first page of the context.
-      const page = await browserContext.newPage();
+      currentPage = await browserContext.newPage();
       // Wait until it is stable.
-      await page.waitForLoadState('domcontentloaded');
+      await currentPage.waitForLoadState('domcontentloaded', {timeout: 15000});
       // Update the name of the current browser type and store it in the page.
-      page.browserTypeName = browserTypeName = typeName;
+      currentPage.browserTypeName = browserTypeName = typeName;
     }
   }
 };
@@ -450,7 +453,7 @@ const goto = async (page, url, timeout, waitUntil, isStrict) => {
     waitUntil
   })
   .catch(error => {
-    console.log(`ERROR: Visit to ${url} timed out before ${waitUntil} (${error.message})`);
+    console.log(`ERROR: Visit to ${url} timed out before ${waitUntil} (${errorStart(error)})`);
     visitTimeoutCount++;
     return 'error';
   });
@@ -687,7 +690,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:
@@ -709,7 +712,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:
@@ -723,14 +726,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');
             }
           }
         }
@@ -950,80 +953,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 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 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) {
-                          // Add the failure data to the report.
-                          act.result.success = false;
-                          act.result.error = 'exhausted';
-                          act.result.typeElementCount = selections.length;
-                          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 {
+                      // 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 {
                       // Add the failure data to the report.
                       act.result.success = false;
-                      act.result.error = 'none';
-                      act.result.typeElementCount = 0;
-                      act.result.message = 'No elements of 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 {
                     // 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 {
                   // 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);
@@ -1032,33 +1026,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 => {
+                // Perform a click or Enter keypress and wait for the network to be idle.
+                const doAndWait = async isClick => {
+                  const move = isClick ? 'click' : 'Enter keypress';
                   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;
+                    await isClick
+                      ? selection.click({timeout: 4000})
+                      : selection.press('Enter', {timeout: 4000});
                     act.result.success = true;
-                    act.result.move = actionIsClick ? 'clicked' : 'Enter pressed';
-                    act.result.newURL = page.url();
+                    act.result.move = move;
                   }
-                  // 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';
+                    act.result.message = `ERROR: ${move} failed`;
+                    console.log(`ERROR: ${move} failed (${errorStart(error)})`);
                     actIndex = -2;
                   }
+                  if (act.result.success) {
+                    try {
+                      await page.context().waitForEvent('networkidle', {timeout: 10000});
+                      act.result.idleTimely = true;
+                    }
+                    catch(error) {
+                      console.log(`ERROR: Network busy after ${move} (${errorStart(error)})`);
+                      act.result.idleTimely = false;
+                    }
+                    // If the move created a new page, make it current.
+                    page = currentPage;
+                    act.result.newURL = page.url();
+                  }
                 };
                 // FUNCTION DEFINITION END
                 // If the move is a button click, perform it.
@@ -1114,7 +1111,7 @@ const doActs = async (report, actIndex, page) => {
                   act.result.target = target || 'DEFAULT';
                   // If the destination is a new page:
                   if (target && target !== '_self') {
-                    // Click the link and wait for the resulting page event.
+                    // Click the link and wait for the network to be idle.
                     doAndWait(true);
                   }
                   // Otherwise, i.e. if the destination is in the current page:
@@ -1131,9 +1128,7 @@ const doActs = async (report, actIndex, page) => {
                     // If the click or load failed:
                     catch(error) {
                       // Quit and report the failure.
-                      console.log(
-                        `ERROR clicking link (${error.message.replace(/\n.+/s, '')})`
-                      );
+                      console.log(`ERROR clicking link (${errorStart(error)})`);
                       act.result.success = false;
                       act.result.error = 'unclickable';
                       act.result.message = 'ERROR: click or load timed out';
@@ -1171,6 +1166,14 @@ const doActs = async (report, actIndex, page) => {
                 }
                 // Otherwise, if it is entering text on a text- or search-input element:
                 else if (['text', 'search'].includes(act.type)) {
+                  act.result.attributes = {};
+                  const {attributes} = act.result;
+                  const type = await selection.getAttribute('type');
+                  const label = await selection.getAttribute('aria-label');
+                  const labelRefs = await selection.getAttribute('aria-labelledby');
+                  attributes.type = type || '';
+                  attributes.label = label || '';
+                  attributes.labelRefs = labelRefs || '';
                   // If the text contains a placeholder for an environment variable:
                   let {what} = act;
                   if (/__[A-Z]+__/.test(what)) {
@@ -1186,7 +1189,7 @@ const doActs = async (report, actIndex, page) => {
                   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.
+                    // Press the Enter key and wait for a network to be idle.
                     doAndWait(false);
                   }
                 }

package/tests/textNodes.js

@@ -15,6 +15,15 @@ exports.reporter = async (page, detailLevel, text) => {
       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();
@@ -26,9 +35,9 @@ exports.reporter = async (page, detailLevel, text) => {
         const data = {
           tagName: element.tagName
         };
-        if (! ['SCRIPT', 'SVG', 'svg'].includes(element.tagName)) {
+        if (! ['STYLE', 'SCRIPT', 'SVG', 'svg'].includes(element.tagName)) {
           if (withText) {
-            data.text = element.textContent;
+            data.text = compact(element.textContent);
           }
           // Add data on its attributes, if any, to the data.
           const {attributes} = element;
@@ -73,16 +82,13 @@ exports.reporter = async (page, detailLevel, text) => {
       // FUNCTION DEFINITIONS END
       const normText = normalize(text);
       // Create a collection of the text nodes.
-      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+      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)
-            && walker.currentNode.parentElement.tagName !== 'SCRIPT'
-          ) {
+          if (normalize(walker.currentNode.nodeValue).includes(normText)) {
             data.nodeCount++;
             matchNodes.push(walker.currentNode);
           }
@@ -120,6 +126,7 @@ exports.reporter = async (page, detailLevel, text) => {
           data.items.push(itemData);
         });
       }
+      document.body.removeChild(tempBody);
       return data;
     }, [detailLevel, text]);
   }