testaro 45.0.2 → 45.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "45.0.2",
+  "version": "45.0.4",
   "description": "Run 1000 web accessibility tests from 10 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/identify.js

@@ -83,6 +83,15 @@ const addIDs = async (locators, recipient) => {
     }
   }
 };
+// Sanitizes a tag name.
+const tagify = tagName => {
+  const lcTagName = tagName.toLowerCase();
+  const safeTagName = lcTagName.replace(/[^a-z0-9]/g, '');
+  if (safeTagName !== lcTagName) {
+    console.log(`ERROR: Tag name ${tagName} invalid`);
+  }
+  return safeTagName;
+};
 // Returns the XPath and box ID of the element of a standard instance.
 exports.identify = async (instance, page) => {
   // If the instance does not yet have both boxID and pathID properties:
@@ -92,7 +101,8 @@ exports.identify = async (instance, page) => {
       boxID: '',
       pathID: ''
     };
-    const {excerpt, id, location, tagName} = instance;
+    const {excerpt, id, location} = instance;
+    const tagName = tagify(instance.tagName);
     const {type, spec} = location;
     // If the instance specifies a CSS selector or XPath location:
     if (['selector', 'xpath'].includes(type)) {
@@ -156,14 +166,14 @@ exports.identify = async (instance, page) => {
     // If either ID remains undefined and the instance specifies a tag name:
     if (tagName && ! (elementID.boxID && elementID.pathID)) {
       // Get locators for elements with the tag name.
-      let locators = page.locator(tagName.toLowerCase());
+      let locators = page.locator(tagName);
       // If there is exactly 1 of them:
       let locatorCount = await locators.count();
       if (locatorCount === 1) {
         // Add a box ID and a path ID to the result.
         await addIDs(locators, elementID);
       }
-      // If either ID remains undefined an the instance also specifies an excerpt:
+      // If either ID remains undefined and the instance also specifies an excerpt:
       if (excerpt && ! (elementID.boxID && elementID.pathID)) {
         // Get the plain text parts of the excerpt, converting ... to an empty string.
         const minTagExcerpt = excerpt.replace(/<[^>]+>/g, '<>');

package/procs/job.js

@@ -266,23 +266,20 @@ exports.isValidJob = job => {
 };
 // Executes an asynchronous function with a time limit.
 exports.doBy = async function(timeLimit, obj, fnName, fnArgs, noticePrefix) {
-  let timer;
+  let timer, fnResolver;
+  // Start the function execution.
+  const fnPromise = new Promise(async function(resolve) {
+    fnResolver = resolve;
+    resolve(await obj[fnName](... fnArgs));
+  });
   // Start a timer.
   const timerPromise = new Promise(resolve => {
     timer = setTimeout(() => {
       console.log(`ERROR: ${noticePrefix} timed out at ${timeLimit} seconds`);
+      setTimeout(() => {fnResolver('aborted')}, 100);
       resolve('timedOut');
     }, 1000 * timeLimit);
   });
-  // Start the function execution.
-  /*
-  const fnPromise = new Promise(async resolve => {
-    resolve(await fn(... fnArgs));
-  });
-  */
-  const fnPromise = new Promise(async function(resolve) {
-    resolve(await obj[fnName](... fnArgs));
-  });
   // Get the timeout or the value returned by the function, whichever is first.
   const result = await Promise.race([timerPromise, fnPromise]);
   clearTimeout(timer);

package/run.js

@@ -812,8 +812,8 @@ const doActs = async (report, actIndex, page) => {
           // Get the start time of the act.
           const startTime = Date.now();
           try {
-            // Get the time limit in milliseconds for the act.
-            const timeLimit = 1000 * timeLimits[act.which] || 15000;
+            // Get the time limit in seconds for the act.
+            const timeLimit = timeLimits[act.which] || 15;
             // Perform the specified tests of the tool.
             const actReport = await require(`./tests/${act.which}`)
             .reporter(page, report, actIndex, timeLimit);

package/tests/aslint.js

@@ -29,6 +29,8 @@
 
 // Module to handle files.
 const fs = require('fs/promises');
+// Utility module.
+const {doBy} = require('../procs/job');
 
 // FUNCTIONS
 
@@ -46,7 +48,7 @@ exports.reporter = async (page, report, actIndex, timeLimit) => {
   const act = report.acts[actIndex];
   const {jobData} = report;
   const scriptNonce = jobData && jobData.lastScriptNonce;
-  // Inject the ASLint bundle and runner into the page.
+  // Inject the ASLint bundle and runner into the head of the page.
   await page.evaluate(args => {
     const {scriptNonce, aslintBundle, aslintRunner} = args;
     // Bundle.
@@ -76,38 +78,60 @@ exports.reporter = async (page, report, actIndex, timeLimit) => {
   const reportLoc = page.locator('#aslintResult');
   // If the injection succeeded:
   if (! data.prevented) {
-    // Get the test results.
-    await reportLoc.waitFor({
-      state: 'attached',
-      timeout: 1000 * timeLimit
-    })
-    .catch(error => {
-      const message
-      = `aslint testing timed out at ${timeLimit} seconds (${error.message.slice(0, 400)})`;
-      console.log(`ERROR: ${message}`);
+    try {
+      // Wait for the test results to be attached to the page.
+      const waitOptions = {
+        state: 'attached',
+        timeout: 1000 * timeLimit
+      };
+      await reportLoc.waitFor(waitOptions);
+      // const timeResult = await doBy(timeLimit, reportLoc, 'waitFor', [waitArg], 'aslint testing');
+      // console.log(`timeResult type is ${typeof timeResult}`);
+      // If the result attachment timed out:
+      /*
+      if (timeResult === 'timedOut') {
+        // Report this.
+        data.prevented = true;
+        data.error = 'Attachment of results to page by aslint timed out';
+        await page.close({runBeforeUnload: true});
+      }
+      */
+    }
+    catch(error) {
+      const message = 'Attachment of test results to page failed';
+      console.log(message);
       data.prevented = true;
-      data.error = message;
-    });
+      data.error = `${message} (${error.message})`;
+    }
   }
-  // If the results arrived in time:
+  // If the injection and the result attachment both succeeded:
   if (! data.prevented) {
-    // Get them.
-    const actReport = await reportLoc.textContent();
-    // Populate the act report.
-    result = JSON.parse(actReport);
-    // If any rules were reported violated:
-    if (result.rules) {
-      // For each such rule:
-      Object.keys(result.rules).forEach(ruleID => {
-        // If the rule was passed or skipped or rules to be tested were specified and exclude it:
-        const excluded = act.rules && ! act.rules.includes(ruleID);
-        const instanceType = result.rules[ruleID].status.type;
-        // If rules to be tested were specified and exclude it or the rule was passed or skipped:
-        if (excluded || ['passed', 'skipped'].includes(instanceType)) {
-          // Delete the rule report.
-          delete result.rules[ruleID];
-        }
-      });
+    // Get their text.
+    const actReport = await doBy(timeLimit, reportLoc, 'textContent', [], 'aslint report retrieval');
+    // If the text was obtained in time:
+    if (actReport !== 'timedOut') {
+      // Populate the act report.
+      result = JSON.parse(actReport);
+      // If any rules were reported violated:
+      if (result.rules) {
+        // For each such rule:
+        Object.keys(result.rules).forEach(ruleID => {
+          // If the rule was passed or skipped or rules to be tested were specified and exclude it:
+          const excluded = act.rules && ! act.rules.includes(ruleID);
+          const instanceType = result.rules[ruleID].status.type;
+          // If rules to be tested were specified and exclude it or the rule was passed or skipped:
+          if (excluded || ['passed', 'skipped'].includes(instanceType)) {
+            // Delete the rule report.
+            delete result.rules[ruleID];
+          }
+        });
+      }
+    }
+    // Otherwise, i.e. if the text was not obtained in time:
+    else {
+      // Report this.
+      data.prevented = true;
+      data.error = 'Retrieval of result text timed out';
     }
   }
   // Return the act report.

package/tests/wave.js

@@ -41,9 +41,10 @@ exports.reporter = async (page, report, actIndex) => {
   const waveKey = process.env.WAVE_KEY;
   // Initialize the results.
   const data = {};
-  const result = {};
+  let result = {};
   try {
     result = await new Promise(resolve => {
+      // Get the test results.
       https.get(
         {
           host: 'wave.webaim.org',
@@ -54,7 +55,7 @@ exports.reporter = async (page, report, actIndex) => {
           response.on('data', chunk => {
             rawReport += chunk;
           });
-          // When the data arrive:
+          // When they arrive:
           response.on('end', async () => {
             // Delete unnecessary properties.
             const actResult = JSON.parse(rawReport);
@@ -114,6 +115,7 @@ exports.reporter = async (page, report, actIndex) => {
     });
   }
   catch (error) {
+    console.log(`ERROR: ${error.message}`);
     data.prevented = true;
     data.error = error.message;
   };