testaro 5.5.7 → 5.5.8

package/create.js

@@ -59,19 +59,27 @@ const runHosts = async (timeStamp, specs) => {
         stdio: [0, 1, 'ignore', 'ipc']
       }
     );
+    let runMoreTimer = null;
     // If the child process times out:
     const timer = setTimeout(async () => {
       clearTimeout(timer);
       // Record the host as timed out.
       timeoutHosts.push(id);
       // Kill the child process.
-      subprocess.kill();
+      subprocess.kill('SIGKILL');
       console.log(`Script for host ${id} exceeded ${timeLimit}-second time limit, so was killed`);
-      // Run the remaining host scripts.
-      await runHosts(timeStamp, specs);
+      // Run the remaining host scripts after a 10-second wait.
+      runMoreTimer = setTimeout(async () => {
+        clearTimeout(runMoreTimer);
+        if (! (successHosts.includes(id) || crashHosts.includes(id))) {
+          console.log('Continuing with the remaining host scripts');
+          await runHosts(timeStamp, specs);
+        }
+      }, 10000);
     }, 1000 * (script.timeLimit || timeLimit));
     // If the child process succeeds:
     subprocess.on('message', async message => {
+      clearTimeout(runMoreTimer);
       clearTimeout(timer);
       // Save its report as a file.
       await fs.writeFile(`${reportDir}/${id}.json`, message);
@@ -83,8 +91,9 @@ const runHosts = async (timeStamp, specs) => {
     });
     // If the child process ends:
     subprocess.on('exit', async () => {
-      // If it ended in a crash:
+      // If its end was not due to success or a timeout:
       if (! (successHosts.includes(id) || timeoutHosts.includes(id))) {
+        clearTimeout(runMoreTimer);
         clearTimeout(timer);
         crashHosts.push(id);
         console.log(`Script for host ${id} crashed`);

package/package.json

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

package/run.js

@@ -634,6 +634,15 @@ const wait = ms => {
     }, ms);
   });
 };
+// Adds an error result to an act.
+const addError = (act, error) => {
+  act.result = {
+    error
+  };
+  if (act.type === 'test') {
+    act.result.prevented = true;
+  }
+};
 // Recursively performs the acts in a report.
 const doActs = async (report, actIndex, page) => {
   process.on('message', message => {
@@ -761,11 +770,11 @@ const doActs = async (report, actIndex, page) => {
           )
           .catch(error => {
             console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
-            act.result = `ERROR waiting for page to be ${act.which}`;
+            addError(act, `ERROR waiting for page to be ${act.which}`);
             actIndex = -2;
           });
           if (actIndex > -2) {
-            act.result = `Page became ${act.which}`;
+            addError(`Page became ${act.which}`);
           }
         }
         // Otherwise, if the act is a page switch:
@@ -977,7 +986,7 @@ const doActs = async (report, actIndex, page) => {
                   await matchingElement.waitForElementState('stable', {timeout: 2000})
                   .catch(error => {
                     console.log(`ERROR waiting for stable ${act.type} (${error.message})`);
-                    act.result = `ERROR waiting for stable ${act.type}`;
+                    addError(act, `ERROR waiting for stable ${act.type}`);
                   });
                   if (! act.result) {
                     const isEnabled = await matchingElement.isEnabled();
@@ -988,7 +997,7 @@ const doActs = async (report, actIndex, page) => {
                       })
                       .catch(error => {
                         console.log(`ERROR checking ${act.type} (${error.message})`);
-                        act.result = `ERROR checking ${act.type}`;
+                        addError(act, `ERROR checking ${act.type}`);
                       });
                       if (! act.result) {
                         act.result = 'checked';
@@ -1250,19 +1259,19 @@ const doActs = async (report, actIndex, page) => {
           // Otherwise, i.e. if redirection is prohibited but occurred:
           else {
             // Add the error result to the act.
-            act.result = `ERROR: Page URL wrong (${url})`;
+            addError(act, `ERROR: Page URL wrong (${url})`);
           }
         }
         // Otherwise, i.e. if the required page URL does not exist:
         else {
           // Add an error result to the act.
-          act.result = 'ERROR: Page has no URL';
+          addError(act, 'ERROR: Page has no URL');
         }
       }
       // Otherwise, i.e. if no page exists:
       else {
         // Add an error result to the act.
-        act.result = 'ERROR: No page identified';
+        addError(act, 'ERROR: No page identified');
       }
     }
     // Otherwise, i.e. if the command is invalid:

package/tests/radioSet.js

@@ -66,22 +66,32 @@ exports.reporter = async (page, withItems) => {
       }
       return radios;
     }, []);
-    // Get an array of all radio buttons.
-    const allRadios = Array.from(document.body.querySelectorAll('input[type=radio'));
-    // Tabulate the results.
-    const totals = data.totals;
-    totals.total = allRadios.length;
-    totals.inSet = setRadios.length;
-    totals.percent = totals.total ? Math.floor(100 * totals.inSet / totals.total) : 'N.A.';
-    // If itemization is required:
-    if (withItems) {
-      // Add it to the results.
-      const nonSetRadios = allRadios.filter(radio => ! setRadios.includes(radio));
-      const items = data.items;
-      items.inSet = setRadios.map(radio => textOf(radio));
-      items.notInSet = nonSetRadios.map(radio => textOf(radio));
+    if (setRadios) {
+      // Get an array of all radio buttons.
+      const allRadios = Array.from(document.body.querySelectorAll('input[type=radio'));
+      // Tabulate the results.
+      const totals = data.totals;
+      totals.total = allRadios.length;
+      totals.inSet = setRadios.length;
+      totals.percent = totals.total ? Math.floor(100 * totals.inSet / totals.total) : 'N.A.';
+      // If itemization is required:
+      if (withItems) {
+        // Add it to the results.
+        const nonSetRadios = allRadios.filter(radio => ! setRadios.includes(radio));
+        const items = data.items;
+        items.inSet = setRadios.map(radio => textOf(radio));
+        items.notInSet = nonSetRadios.map(radio => textOf(radio));
+      }
+      return {result: data};
+    }
+    else {
+      return {
+        result: {
+          prevented: true,
+          error: 'ERROR identifying homogeneous field sets'
+        }
+      };
     }
-    return {result: data};
   }, args);
   return await dataJSHandle.jsonValue();
 };

package/tests/tabNav.js

@@ -92,84 +92,92 @@ exports.reporter = async (page, withItems) => {
     const testKey = async (
       tabs, tabElement, keyName, keyProp, goodIndex, elementIsCorrect, itemData
     ) => {
-      let pressed = true;
-      // Click the tab element, to make the focus on it effective.
-      await tabElement.click({
-        timeout: 500
-      })
-      .catch(async error => {
-        await tabElement.click({
-          force: true
-        });
-      })
-      .catch(error => {
-        console.log(
-          `ERROR clicking tab element ${itemData.text} (${error.message.replace(/\n.+/s, '')})`
-        );
-      pressed = false;
-      });
-      // Increment the counts of navigations and key navigations.
-      data.totals.navigations.all.total++;
-      data.totals.navigations.specific[keyProp].total++;
       const {navigationErrors} = itemData;
-      // If the click succeeded:
-      if (pressed) {
-        // Refocus the tab element and press the specified key (page.keyboard.press may fail).
-        await tabElement.press(keyName, {
-          timeout: 1000
+      if (navigationErrors) {
+        let pressed = true;
+        // Click the tab element, to make the focus on it effective.
+        await tabElement.click({
+          timeout: 500
+        })
+        .catch(async error => {
+          console.log(
+            `ERROR clicking tab element ${itemData.text} (${error.message.replace(/\n.+/s, '')})`
+          );
+          await tabElement.click({
+            force: true
+          });
         })
         .catch(error => {
-          console.log(`ERROR: could not press ${keyName} (${error.message})`);
+          console.log(
+            `ERROR force-clicking tab element ${itemData.text} (${error.message.replace(/\n.+/s, '')})`
+          );
           pressed = false;
         });
-        // If the refocus and keypress succeeded:
+        // Increment the counts of navigations and key navigations.
+        data.totals.navigations.all.total++;
+        data.totals.navigations.specific[keyProp].total++;
+        // If the click succeeded:
         if (pressed) {
-          // Identify which tab element is now focused, if any.
-          const focusIndex = await focusedTab(tabs);
-          // If the focus is correct:
-          if (focusIndex === goodIndex) {
-            // Increment the counts of correct navigations and correct key navigations.
-            data.totals.navigations.all.correct++;
-            data.totals.navigations.specific[keyProp].correct++;
+          // Refocus the tab element and press the specified key (page.keyboard.press may fail).
+          await tabElement.press(keyName, {
+            timeout: 1000
+          })
+          .catch(error => {
+            console.log(`ERROR: could not press ${keyName} (${error.message})`);
+            pressed = false;
+          });
+          // If the refocus and keypress succeeded:
+          if (pressed) {
+            // Identify which tab element is now focused, if any.
+            const focusIndex = await focusedTab(tabs);
+            // If the focus is correct:
+            if (focusIndex === goodIndex) {
+              // Increment the counts of correct navigations and correct key navigations.
+              data.totals.navigations.all.correct++;
+              data.totals.navigations.specific[keyProp].correct++;
+            }
+            // Otherwise, i.e. if the focus is incorrect:
+            else {
+              // Increment the counts of incorrect navigations and incorrect key navigations.
+              data.totals.navigations.all.incorrect++;
+              data.totals.navigations.specific[keyProp].incorrect++;
+              // Update the element status to incorrect.
+              elementIsCorrect = false;
+              // If itemization is required:
+              if (withItems) {
+                // Update the element report.
+                navigationErrors.push(keyName);
+              }
+            }
+            return elementIsCorrect;
           }
-          // Otherwise, i.e. if the focus is incorrect:
+          // Otherwise, i.e. if the refocus or keypress failed:
           else {
             // Increment the counts of incorrect navigations and incorrect key navigations.
             data.totals.navigations.all.incorrect++;
             data.totals.navigations.specific[keyProp].incorrect++;
-            // Update the element status to incorrect.
-            elementIsCorrect = false;
-            // If itemization is required:
-            if (withItems) {
+            // If itemization is required and a focus failure has not yet been reported:
+            if (withItems && ! navigationErrors.includes('focus')) {
               // Update the element report.
-              navigationErrors.push(keyName);
+              navigationErrors.push('focus');
             }
+            return false;
           }
-          return elementIsCorrect;
         }
-        // Otherwise, i.e. if the refocus or keypress failed:
+        // Otherwise, i.e. if the click failed:
         else {
           // Increment the counts of incorrect navigations and incorrect key navigations.
           data.totals.navigations.all.incorrect++;
           data.totals.navigations.specific[keyProp].incorrect++;
-          // If itemization is required and a focus failure has not yet been reported:
-          if (withItems && ! navigationErrors.includes('focus')) {
+          // If itemization is required and a click failure has not yet been reported:
+          if (withItems && ! navigationErrors.includes('click')) {
             // Update the element report.
-            navigationErrors.push('focus');
+            navigationErrors.push('click');
           }
           return false;
         }
       }
-      // Otherwise, i.e. if the click failed:
       else {
-        // Increment the counts of incorrect navigations and incorrect key navigations.
-        data.totals.navigations.all.incorrect++;
-        data.totals.navigations.specific[keyProp].incorrect++;
-        // If itemization is required and a click failure has not yet been reported:
-        if (withItems && ! navigationErrors.includes('click')) {
-          // Update the element report.
-          navigationErrors.push('click');
-        }
         return false;
       }
     };

package/tests/tenon.js

@@ -98,10 +98,13 @@ exports.reporter = async (tenonData, id) => {
       }
       // Otherwise, i.e. if the test is still running or failed:
       else {
-        return {result: {
-          error: 'ERROR: Tenon result not retrieved',
-          status
-        }};
+        return {
+          result: {
+            prevented: true,
+            error: 'ERROR: Tenon test stalled or crashed',
+            status
+          }
+        };
       }
     }
     // Otherwise, if the test is still running after a wait for its status: