testaro 5.7.4 → 5.8.0

package/package.json

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

package/run.js

@@ -70,7 +70,7 @@ const browserTypeNames = {
   'firefox': 'Firefox'
 };
 // Items that may be waited for.
-const waitables = ['url', 'title', 'body'];
+const waitables = ['url', 'title', 'body', 'mailLink'];
 // Tenon data.
 const tenonData = {
   accessToken: '',
@@ -106,6 +106,7 @@ let visitRejectionCount = 0;
 let visitLatency = 0;
 let actCount = 0;
 // Facts about the current browser.
+let browser;
 let browserContext;
 let browserTypeName;
 let requestedURL = '';
@@ -257,12 +258,24 @@ const isValidReport = async report => {
 
 // ########## OTHER FUNCTIONS
 
+// Closes the current browser.
+const browserClose = async () => {
+  if (browser) {
+    const contexts = browser.contexts();
+    for (const context of contexts) {
+      await context.close();
+    }
+    await browser.close();
+  }
+};
 // Launches a browser.
 const launch = async typeName => {
   const browserType = require('playwright')[typeName];
   // If the specified browser type exists:
   if (browserType) {
-    // Launch a browser of the specified type.
+    // Close the current browser, if any.
+    await browserClose();
+    // Launch a browser of that type.
     const browserOptions = {};
     if (debug) {
       browserOptions.headless = false;
@@ -271,7 +284,7 @@ const launch = async typeName => {
       browserOptions.slowMo = waits;
     }
     let healthy = true;
-    const browser = await browserType.launch(browserOptions)
+    browser = await browserType.launch(browserOptions)
     .catch(error => {
       healthy = false;
       console.log(`ERROR launching browser: ${error.message.replace(/\n.+/s, '')}`);
@@ -429,7 +442,7 @@ const textOf = async (page, element) => {
     return null;
   }
 };
-// Returns an element of a type case-insensitively matching a text.
+// Returns an element of a type case-insensitively including a text.
 const matchElement = async (page, selector, matchText, index = 0) => {
   if (matchText) {
     // If the page still exists:
@@ -441,14 +454,18 @@ const matchElement = async (page, selector, matchText, index = 0) => {
       if (selections.length) {
         // If there are enough to make a match possible:
         if (index < selections.length) {
-          // Return the specified one, if any.
+          // For each element of the specified type:
           let matchCount = 0;
           const selectionTexts = [];
           for (const 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 count of such elements with such texts found so far is the specified count:
               if (matchCount++ === index) {
+                // Return it as the matching element.
                 return {
                   success: true,
                   matchingElement: selection
@@ -648,7 +665,8 @@ const isTrue = (object, specs) => {
 // Adds a wait error result to an act.
 const waitError = (page, act, error, what) => {
   console.log(`ERROR waiting for ${what} (${error.message})`);
-  act.result = {url: page.url()};
+  act.result.found = false;
+  act.result.url = page.url();
   act.result.error = `ERROR waiting for ${what}`;
   return false;
 };
@@ -741,49 +759,95 @@ const doActs = async (report, actIndex, page) => {
         // Otherwise, if the act is a wait for text:
         else if (act.type === 'wait') {
           const {what, which} = act;
-          console.log(`>> for ${what} to include “${which}”`);
-          // Wait 5 or 10 seconds for the specified text, and quit if it does not appear.
-          if (act.what === 'url') {
-            await page.waitForURL(act.which, {timeout: 15000})
-            .catch(error => {
+          console.log(`>> ${what}`);
+          const result = act.result = {};
+          // Wait for the specified text, and quit if it does not appear.
+          if (what === 'url') {
+            try {
+              await page.waitForURL(which, {timeout: 15000});
+              result.found = true;
+              result.url = page.url();
+            }
+            catch(error) {
               actIndex = -2;
               waitError(page, act, error, 'URL');
-            });
+            }
           }
-          else if (act.what === 'title') {
-            await page.waitForFunction(
-              text => document && document.title && document.title.includes(text),
-              act.which,
-              {
-                polling: 1000,
-                timeout: 5000
-              }
-            )
-            .catch(error => {
+          else if (what === 'title') {
+            try {
+              await page.waitForFunction(
+                text => document
+                && document.title
+                && document.title.toLowerCase().includes(text.toLowerCase()),
+                which,
+                {
+                  polling: 1000,
+                  timeout: 5000
+                }
+              );
+              result.found = true;
+              result.title = await page.title(); 
+            }
+            catch(error) {
               actIndex = -2;
               waitError(page, act, error, 'title');
-            });
+            }
           }
-          else if (act.what === 'body') {
-            await page.waitForFunction(
-              text => document && document.body && document.body.innerText.includes(text),
-              act.which,
-              {
-                polling: 2000,
-                timeout: 10000
-              }
-            )
-            .catch(async error => {
+          else if (what === 'body') {
+            try {
+              await page.waitForFunction(
+                text => document
+                && document.body
+                && document.body.innerText.toLowerCase().includes(text.toLowerCase()),
+                which,
+                {
+                  polling: 2000,
+                  timeout: 10000
+                }
+              );
+              result.found = true;
+            }
+            catch(error) {
               actIndex = -2;
               waitError(page, act, error, 'body');
-            });
+            }
           }
-          // If the text was found:
-          if (actIndex > -2) {
-            // Add this to the report.
-            act.result = {url: page.url()};
-            if (act.what === 'title') {
-              act.result.title = await page.title();
+          else if (what === 'mailLink') {
+            try {
+              const addressJSHandle = await page.waitForFunction(
+                text => {
+                  const mailLinks = document
+                  && document.body
+                  && document.body.querySelectorAll('a[href^="mailto:"]');
+                  if (mailLinks && mailLinks.length) {
+                    const textLC = text.toLowerCase();
+                    const a11yLink = Array
+                    .from(mailLinks)
+                    .find(link => link.textContent.toLowerCase().includes(textLC));
+                    if (a11yLink) {
+                      return a11yLink.href.replace(/^mailto:/, '');
+                    }
+                    else {
+                      return false;
+                    }
+                  }
+                  else {
+                    return false;
+                  }
+                },
+                which,
+                {
+                  polling: 1000,
+                  timeout: 5000
+                }
+              );
+              const address = await addressJSHandle.jsonValue();
+              result.found = true;
+              result.address = address;
+            }
+            catch(error) {
+              actIndex = -2;
+              waitError(page, act, error, 'mailLink');
             }
           }
         }
@@ -1041,24 +1105,36 @@ const doActs = async (report, actIndex, page) => {
                   await matchingElement.focus({timeout: 2000});
                   act.result = 'focused';
                 }
-                // Otherwise, if it is clicking a link, perform it.
+                // Otherwise, if it is clicking a link:
                 else if (act.type === 'link') {
+                  // Try to click it.
                   const href = await matchingElement.getAttribute('href');
                   const target = await matchingElement.getAttribute('target');
-                  await matchingElement.click({timeout: 2000})
-                  .catch(async () => {
-                    console.log('ERROR: First attempt to click link timed out');
+                  await matchingElement.click({timeout: 3000})
+                  // If it cannot be clicked within 3 seconds:
+                  .catch(async error => {
+                    // Try to force-click it without actionability checks.
+                    const errorSummary = error.message.replace(/\n.+/, '');
+                    console.log(`ERROR: Link to ${href} not clickable (${errorSummary})`);
                     await matchingElement.click({
-                      force: true,
-                      timeout: 10000
+                      force: true
                     })
-                    .catch(() => {
+                    // If it cannot be force-clicked:
+                    .catch(error => {
+                      // Quit and report the failure.
                       actIndex = -2;
-                      console.log('ERROR: Second (forced) attempt to click link timed out');
-                      act.result = 'ERROR: Normal and forced click attempts timed out';
+                      const errorSummary = error.message.replace(/\n.+/, '');
+                      console.log(`ERROR: Link to ${href} not force-clickable (${errorSummary})`);
+                      act.result = {
+                        href: href || 'NONE',
+                        target: target || 'NONE',
+                        error: 'ERROR: Normal and forced attempts to click link timed out'
+                      };
                     });
                   });
+                  // If it was clicked:
                   if (actIndex > -2) {
+                    // Report the success.
                     act.result = {
                       href: href || 'NONE',
                       target: target || 'NONE',
@@ -1076,7 +1152,9 @@ const doActs = async (report, actIndex, page) => {
                       const optionText = await option.textContent();
                       optionTexts.push(optionText);
                     }
-                    const matchTexts = optionTexts.map((text, index) => text.includes(act.what) ? index : -1);
+                    const matchTexts = optionTexts.map(
+                      (text, index) => text.includes(act.what) ? index : -1
+                    );
                     const index = matchTexts.filter(text => text > -1)[act.index || 0];
                     if (index !== undefined) {
                       await matchingElement.selectOption({index});
@@ -1172,7 +1250,7 @@ const doActs = async (report, actIndex, page) => {
                     }
                     // If there is a current element:
                     if (currentElement) {
-                      // If it was already reached within this command performance:
+                      // If it was already reached within this act:
                       if (currentElement.dataset.pressesReached === actCount.toString(10)) {
                         // Report the error.
                         console.log(`ERROR: ${currentElement.tagName} element reached again`);
@@ -1306,6 +1384,8 @@ const doActs = async (report, actIndex, page) => {
       const errorMsg = `ERROR: Invalid command of type ${act.type}`;
       act.result = errorMsg;
       console.log(errorMsg);
+      // Quit.
+      actIndex = -2;
     }
     // Perform the remaining acts.
     await doActs(report, actIndex + 1, page);

package/tests/hover.js

@@ -28,6 +28,10 @@
   value in the same location being the target.
 */
 
+// VARIABLES
+
+let hasTimedOut = false;
+
 // FUNCTIONS
 
 // Samples a population and returns the sample.
@@ -59,153 +63,172 @@ const textOf = async (element, limit) => {
 };
 // Recursively reports impacts of hovering over triggers.
 const find = async (data, withItems, page, region, sample, popRatio) => {
-  // If any potential triggers remain:
-  if (sample.length) {
-    // Identify the first of them.
-    const firstTrigger = sample[0];
-    const tagNameJSHandle = await firstTrigger.getProperty('tagName')
-    .catch(error => {
-      return '';
-    });
-    if (tagNameJSHandle) {
-      const tagName = await tagNameJSHandle.jsonValue();
-      // Identify the root of a subtree likely to contain impacted elements.
-      let root = firstTrigger;
-      if (['A', 'BUTTON', 'LI'].includes(tagName)) {
-        const rootJSHandle = await page.evaluateHandle(
-          firstTrigger => {
-            const parent = firstTrigger.parentElement || firstTrigger;
-            const grandparent = parent.parentElement || parent;
-            const greatGrandparent = grandparent.parentElement || parent;
-            return firstTrigger.tagName === 'LI' ? grandparent : greatGrandparent;
-          },
-          firstTrigger
-        );
-        root = rootJSHandle.asElement();
-      }
-      // Identify all the descendants of the root.
-      const preDescendants = await root.$$(':visible');
-      // Identify their opacities.
-      const preOpacities = await page.evaluate(elements => elements.map(
-        element => window.getComputedStyle(element).opacity
-      ), preDescendants);
-      try {
-        // Hover over the trigger.
-        await firstTrigger.hover({
-          timeout: 500,
-          noWaitAfter: true
-        });
-        // Repeatedly seeks impacts.
-        const getImpacts = async (interval, triesLeft) => {
-          // If the allowed trial count has not yet been exhausted:
-          if (triesLeft--) {
-            // Get the collection of descendants of the root.
-            const postDescendants = await root.$$(':visible');
-            // Identify the prior descandants of the root still in existence.
-            const remainerIndexes = await page.evaluate(args => {
-              const preDescendants = args[0];
-              const postDescendants = args[1];
-              const remainerIndexes = preDescendants
-              .map((element, index) => postDescendants.includes(element) ? index : -1)
-              .filter(index => index > -1);
-              return remainerIndexes;
-            }, [preDescendants, postDescendants]);
-            // Get the count of elements added by the hover event.
-            const additionCount = postDescendants.length - remainerIndexes.length;
-            const removalCount = preDescendants.length - remainerIndexes.length;
-            const remainers = [];
-            for (const index of remainerIndexes) {
-              remainers.push({
-                element: preDescendants[index],
-                preOpacity: preOpacities[index],
-                postOpacity: await page.evaluate(
-                  element => window.getComputedStyle(element).opacity, preDescendants[index]
-                )
-              });
-            }
-            const opacityChangers = remainers
-            .filter(remainer => remainer.postOpacity !== remainer.preOpacity);
-            const opacityImpact = opacityChangers ? await page.evaluate(changers => changers.reduce(
-              (total, current) => total + current.element.querySelectorAll('*').length, 0
-            ), opacityChangers) : 0;
-            if (additionCount || removalCount || opacityChangers.length) {
-              return {
-                additionCount,
-                removalCount,
-                opacityChangers,
-                opacityImpact
-              };
-            }
-            else {
-              return await new Promise(resolve => {
-                setTimeout(() => {
-                  resolve(getImpacts(interval, triesLeft));
-                }, interval);
-              });
-            }
-          }
-          else {
-            return null;
-          }
-        };
-        // Repeatedly seek impacts of the hover at intervals.
-        const impacts = await getImpacts(300, 4);
-        // If there were any:
-        if (impacts) {
-          // Hover over the upper-left corner of the page, to undo any impacts.
-          await page.hover('body', {
-            position: {
-              x: 0,
-              y: 0
+  // If any potential triggers remain and the test has not timed out:
+  if (sample.length && ! hasTimedOut) {
+    // Get and report the impacts until and unless the test times out.
+    try {
+      // Identify the first of them.
+      const firstTrigger = sample[0];
+      const tagNameJSHandle = await firstTrigger.getProperty('tagName')
+      .catch(error => '');
+      if (tagNameJSHandle) {
+        const tagName = await tagNameJSHandle.jsonValue();
+        // Identify the root of a subtree likely to contain impacted elements.
+        let root = firstTrigger;
+        if (['A', 'BUTTON', 'LI'].includes(tagName)) {
+          const rootJSHandle = await page.evaluateHandle(
+            firstTrigger => {
+              const parent = firstTrigger.parentElement || firstTrigger;
+              const grandparent = parent.parentElement || parent;
+              const greatGrandparent = grandparent.parentElement || parent;
+              return firstTrigger.tagName === 'LI' ? grandparent : greatGrandparent;
             },
+            firstTrigger
+          );
+          root = rootJSHandle.asElement();
+        }
+        // Identify all the visible descendants of the root.
+        const preDescendants = await root.$$(':visible');
+        // Identify their opacities.
+        const preOpacities = await page.evaluate(elements => elements.map(
+          element => window.getComputedStyle(element).opacity
+        ), preDescendants);
+        try {
+          // Hover over the trigger.
+          await firstTrigger.hover({
             timeout: 500,
-            force: true,
             noWaitAfter: true
           });
-          // Wait for any delayed and/or slowed hover reaction.
-          await page.waitForTimeout(200);
-          await root.waitForElementState('stable');
-          // Increment the counts of triggers and impacts.
-          const {additionCount, removalCount, opacityChangers, opacityImpact} = impacts;
-          data.totals.impactTriggers += popRatio;
-          data.totals.additions += popRatio * additionCount;
-          data.totals.removals += popRatio * removalCount;
-          data.totals.opacityChanges += popRatio * opacityChangers.length;
-          data.totals.opacityImpact += popRatio * opacityImpact;
-          // If details are to be reported:
-          if (withItems) {
-            // Report them.
-            data.items[region].impactTriggers.push({
-              tagName,
-              text: await textOf(firstTrigger, 50),
-              additions: additionCount,
-              removals: removalCount,
-              opacityChanges: opacityChangers.length,
-              opacityImpact
+          // FUNCTION DEFINITION START
+          // Repeatedly seeks impacts.
+          const getImpacts = async (interval, triesLeft) => {
+            // If the allowed trial count has not yet been exhausted:
+            if (triesLeft-- && ! hasTimedOut) {
+              // Get the collection of descendants of the root.
+              const postDescendants = await root.$$(':visible');
+              // Identify the prior descandants of the root still in existence.
+              const remainerIndexes = await page.evaluate(args => {
+                const preDescendants = args[0];
+                const postDescendants = args[1];
+                const remainerIndexes = preDescendants
+                .map((element, index) => postDescendants.includes(element) ? index : -1)
+                .filter(index => index > -1);
+                return remainerIndexes;
+              }, [preDescendants, postDescendants]);
+              // Get the count of elements added by the hover event.
+              const additionCount = postDescendants.length - remainerIndexes.length;
+              const removalCount = preDescendants.length - remainerIndexes.length;
+              const remainers = [];
+              for (const index of remainerIndexes) {
+                remainers.push({
+                  element: preDescendants[index],
+                  preOpacity: preOpacities[index],
+                  postOpacity: await page.evaluate(
+                    element => window.getComputedStyle(element).opacity, preDescendants[index]
+                  )
+                });
+              }
+              const opacityChangers = remainers
+              .filter(remainer => remainer.postOpacity !== remainer.preOpacity);
+              const opacityImpact = opacityChangers ? await page.evaluate(changers => changers.reduce(
+                (total, current) => total + current.element.querySelectorAll('*').length, 0
+              ), opacityChangers) : 0;
+              if (additionCount || removalCount || opacityChangers.length) {
+                return {
+                  additionCount,
+                  removalCount,
+                  opacityChangers,
+                  opacityImpact
+                };
+              }
+              else {
+                return await new Promise(resolve => {
+                  setTimeout(() => {
+                    resolve(getImpacts(interval, triesLeft));
+                  }, interval);
+                });
+              }
+            }
+            else {
+              return null;
+            }
+          };
+          // FUNCTION DEFINITION END
+          // Repeatedly seek impacts of the hover at intervals.
+          const impacts = await getImpacts(300, 4);
+          // If there were any:
+          if (impacts) {
+            // Hover over the upper-left corner of the page, to undo any impacts.
+            await page.hover('body', {
+              position: {
+                x: 0,
+                y: 0
+              },
+              timeout: 500,
+              force: true,
+              noWaitAfter: true
             });
+            // Wait for any delayed and/or slowed hover reaction.
+            await page.waitForTimeout(200);
+            await root.waitForElementState('stable');
+            // Increment the counts of triggers and impacts.
+            const {additionCount, removalCount, opacityChangers, opacityImpact} = impacts;
+            if (hasTimedOut) {
+              return Promise.resolve('');
+            }
+            else {
+              data.totals.impactTriggers += popRatio;
+              data.totals.additions += popRatio * additionCount;
+              data.totals.removals += popRatio * removalCount;
+              data.totals.opacityChanges += popRatio * opacityChangers.length;
+              data.totals.opacityImpact += popRatio * opacityImpact;
+              // If details are to be reported:
+              if (withItems) {
+                // Report them.
+                data.items[region].impactTriggers.push({
+                  tagName,
+                  text: await textOf(firstTrigger, 50),
+                  additions: additionCount,
+                  removals: removalCount,
+                  opacityChanges: opacityChangers.length,
+                  opacityImpact
+                });
+              }
+            }
           }
         }
-      }
-      catch (error) {
-        console.log(`ERROR hovering (${error.message.replace(/\n.+/s, '')})`);
-        data.totals.unhoverables++;
-        if (withItems) {
-          try {
-            const id = await firstTrigger.getAttribute('id');
-            data.items[region].unhoverables.push({
-              tagName,
-              id: id || '',
-              text: await textOf(firstTrigger, 50)
-            });
+        catch (error) {
+          console.log(`ERROR hovering (${error.message.replace(/\n.+/s, '')})`);
+          if (hasTimedOut) {
+            return Promise.resolve('');
           }
-          catch(error) {
-            console.log('ERROR itemizing unhoverable element');
+          else {
+            data.totals.unhoverables++;
+            if (withItems) {
+              try {
+                const id = await firstTrigger.getAttribute('id');
+                data.items[region].unhoverables.push({
+                  tagName,
+                  id: id || '',
+                  text: await textOf(firstTrigger, 50)
+                });
+              }
+              catch(error) {
+                console.log('ERROR itemizing unhoverable element');
+              }
+            }
           }
         }
       }
+      // Process the remaining potential triggers.
+      await find(data, withItems, page, region, sample.slice(1), popRatio);
     }
-    // Process the remaining potential triggers.
-    await find(data, withItems, page, region, sample.slice(1), popRatio);
+    catch(error) {
+      console.log(`ERROR: Test quit when remaining sample size was ${sample.length}`);
+    }
+  }
+  else {
+    return Promise.resolve('');
   }
 };
 // Performs the hover test and reports results.
@@ -213,7 +236,7 @@ exports.reporter = async (
   page, headSize = 0, headSampleSize = -1, tailSampleSize = -1, withItems
 ) => {
   // Initialize the result.
-  const data = {
+  let data = {
     totals: {
       triggers: 0,
       headTriggers: 0,
@@ -259,17 +282,34 @@ exports.reporter = async (
   // Get the head and tail samples.
   const headSample = getSample(headTriggers, headSampleSize);
   const tailSample = tailSampleSize === -1 ? tailTriggers : getSample(tailTriggers, tailSampleSize);
+  // Set a time limit to handle pages that slow the operations of this test.
+  const timeLimit = Math.round(1.3 * (headSample.length + tailSample.length));
+  const timeout = setTimeout(async () => {
+    await page.close();
+    console.log(
+      `ERROR: hover test timed out at ${timeLimit} seconds; page closed`
+    );
+    hasTimedOut = true;
+    data = {
+      prevented: true,
+      error: 'ERROR: hover test timed out'
+    };
+    clearTimeout(timeout);
+  }, 1000 * timeLimit);
   // Find and document the impacts.
-  if (headSample.length) {
+  if (headSample.length && ! hasTimedOut) {
     await find(data, withItems, page, 'head', headSample, headTriggerCount / headSample.length);
   }
-  if (tailSample.length) {
+  if (tailSample.length && ! hasTimedOut) {
     await find(data, withItems, page, 'tail', tailSample, tailTriggerCount / tailSample.length);
   }
+  clearTimeout(timeout);
   // Round the reported totals.
-  Object.keys(data.totals).forEach(key => {
-    data.totals[key] = Math.round(data.totals[key]);
-  });
+  if (! hasTimedOut) {
+    Object.keys(data.totals).forEach(key => {
+      data.totals[key] = Math.round(data.totals[key]);
+    });
+  }
   // Return the result.
   return {result: data};
 };

package/tests/nuVal.js

@@ -11,7 +11,7 @@ const https = require('https');
 exports.reporter = async page => {
   const pageContent = await page.content();
   // Get the data from a Nu validation.
-  const data = await new Promise((resolve, reject) => {
+  const dataPromise = new Promise(resolve => {
     try {
       const request = https.request(
         {
@@ -40,7 +40,7 @@ exports.reporter = async page => {
               return resolve(result);
             }
             catch (error) {
-              console.log(`Validation failed (${error.message})`);
+              console.log(`ERROR: Validation failed (${error.message})`);
               return resolve({
                 prevented: true,
                 error: error.message,
@@ -54,7 +54,7 @@ exports.reporter = async page => {
       request.end();
       request.on('error', error => {
         console.log(error.message);
-        return reject({
+        return resolve({
           prevented: true,
           error: error.message
         });
@@ -62,11 +62,22 @@ exports.reporter = async page => {
     }
     catch(error) {
       console.log(error.message);
-      return reject({
+      return resolve({
         prevented: true,
         error: error.message
       });
     }
   });
+  const timeoutPromise = new Promise(resolve => {
+    const timeLimit = 12;
+    const timeoutID = setTimeout(() => {
+      resolve({
+        prevented: true,
+        error: `ERROR: Validation timed out at ${timeLimit} seconds`
+      });
+      clearTimeout(timeoutID);
+    }, 1000 * timeLimit);
+  });
+  const data = await Promise.race([dataPromise, timeoutPromise]);
   return {result: data};
 };