testaro 45.0.13 → 46.0.1

package/README.md

@@ -136,7 +136,6 @@ Here is an example of a job:
   id: '250110T1200-7f-4',
   what: 'monthly health check',
   strict: true,
-  isolate: true,
   standard: 'also',
   observe: false,
   device: {
@@ -155,7 +154,6 @@ Here is an example of a job:
     }
   },
   browserID: 'webkit',
-  timeLimit: 80,
   creationTimeStamp: '241229T0537',
   executionTimeStamp: '250110T1200',
   sendReportTo: 'https://abccorp.com/api/report',
@@ -170,11 +168,9 @@ Here is an example of a job:
     requester: 'malavu@abccorp.com'
   },
   acts: [
-    {
-      type: 'launch'
-    },
     {
       type: 'test',
+      launch: {},
       which: 'axe',
       detailLevel: 2,
       rules: ['landmark-complementary-is-top-level'],
@@ -182,6 +178,7 @@ Here is an example of a job:
     },
     {
       type: 'test',
+      launch: {},
       which: 'qualWeb',
       withNewContent: false,
       rules: ['QW-BP25', 'QW-BP26']
@@ -191,20 +188,18 @@ Here is an example of a job:
 }
 ```
 
-This job contains three _acts_, telling Testaro to:
-1. Launch a Webkit browser without a reduced-motion setting, open a window with the properties of an iPhone 8 device, create a page (tab), and navigate to `https://abccorp.com/mgmt/realproperty.html`.
-1. Perform the test for the `landmark-complementary-is-top-level` rule of the `axe` tool and report the test result with Axe detail level 2.
-1. Perform the tests for rules `QW-BP25` and `QW-BP26` of the `qualWeb` tool on the existing page.
+This job tells Testaro to perform two acts. One performs one test of the Axe tool wih reporting at detail level 2, and the other performs two tests of the QualWeb tool.
+
+Each act includes a `launch` property with a default value. That instructs Testaro, before performing those tests, to launch a new Webkit browser, open a context (window) with some properties of an iPhone 8 and without a reduced-motion setting, create a page (tab), and navigate to a particular page of the `abccorp.com` website.
 
 Job properties:
 - `id`: a string uniquely identifying the job.
 - `what`: a description of the job.
 - `strict`: `true` or `false`, indicating whether _substantive redirections_ should be treated as failures. These are redirections that do more than add or subtract a final slash.
-- `standard`: `'also'`, `'only'`, or `'no'`, indicating whether rule-violation instances are to be reported in tool-native formats and also in the Testaro standard format, only in the standard format, or only in the tool-native formats.
+- `standard`: whether standardized versions of tool reports are to accompany the original versions (`'also'`), replace the original versions (`'only'`), or not be produced (`'no'`).
 - `observe`: `true` or `false`, indicating whether tool and Testaro-rule invocations are to be reported to the server as they occur, so that the server can update a waiting client.
-- `device`: the ID of a device and the properties of each new browser context (window) that will be set for conformity to that device, unless overridden by a `launch` act. It must be `'default'` or the ID of one of [about 125 devices recognized by Playwright](https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json).
-- `browserID`: the ID of the browser to be used, unless overridden by a `launch` act. It must be `'chromium'`, `'firefox'`, or `'webkit`'.
-- `timeLimit`: the number of seconds allowed for the execution of the job.
+- `device`: the ID of a device and the properties of each new browser context (window) that will be set for conformity to that device, unless overridden by an act. It must be `'default'` or the ID of one of [about 125 devices recognized by Playwright](https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json).
+- `browserID`: the ID of the browser to be used, unless overridden by an act. It must be `'chromium'`, `'firefox'`, or `'webkit`'.
 - `creationTimeStamp`: a string in `yymmddThhMM` format, describing when the job was created.
 - `executionTimeStamp`: a string in `yymmddThhMM` format, specifying a date and time before which the job is not to be performed.
 - `sendReportTo`: the URL to which the job report is to be sent, or `''` if not a `netWatch` job.
@@ -218,19 +213,31 @@ Job properties:
 
 Each act object has a `type` property and optionally has a `name` property (used in branching, described below). It must or may have other properties, depending on the value of `type`.
 
-### Act sequence
-
-The first act in any job has the type `launch`, as shown in the example above. It launches a browser and then uses it to visit a URL. 
-
 ### Act types
 
-The acts after the first can tell Testaro to perform any of:
-- _moves_ (clicks, text inputs, hovers, etc.)
+The acts can tell Testaro to perform any of:
 - _navigations_ (browser launches, visits to URLs, waits for page conditions, etc.)
+- _moves_ (clicks, text inputs, hovers, etc.)
 - _alterations_ (changes to the page)
 - _tests_ (one or more of the tests defined by a tool)
 - _branching_ (continuing from an act other than the next one)
 
+#### Navigations
+
+An example of a **navigation** is:
+
+```json
+{
+  "type": "wait",
+  "which": "travel",
+  "what": "title"
+}
+```
+
+In this case, Testaro waits until the page title contains the string “travel” (case-insensitively).
+
+There is also a `launch` act. You need it in any job before other acts can be performed, unless the acts are all `test` acts and they include `launch` properties, as in the job example above. That `launch` property is a compact alternative to a `launch` act.
+
 #### Moves
 
 An example of a **move** is:
@@ -250,24 +257,6 @@ In identifying the target element for a move, Testaro matches the `which` proper
 
 When the texts of multiple elements of the same type will contain the same `which` value, you can include an `index` property to specify the index of the target element, among all those that will match.
 
-#### Navigations
-
-An example of a **navigation** is the act of type `launch` in the job example above. That `launch` act has only a `type` property. If you want a particular `launch` act to use a different browser type or to navigate to a different target URL from the job defaults, the `launch` act can have a `browserID` and/or a `url` property.
-
-If any act alters the page, you can restore the page to its original state for the next act by inserting a new `launch` act (and, if necessary, additional page-specific acts) between them.
-
-Another navigation example is:
-
-```json
-{
-  "type": "wait",
-  "which": "travel",
-  "what": "title"
-}
-```
-
-In this case, Testaro waits until the page title contains the string “travel” (case-insensitively).
-
 #### Alterations
 
 An example of an **alteration** is:
@@ -306,18 +295,6 @@ An act of type `test` performs the tests of a tool and reports a result. The res
 
 The `which` property of a `test` act identifies a tool, such as `alfa` or `testaro`.
 
-#### Target modification
-
-Some tools modify the page, so isolation of tests from one another requires that a browser be relaunched or, at least, navigate to the URL again, after a test act running any of those tools before a test act running another tool.
-
-Of the 10 tools, 6 are target-modifying:
-- `alfa`
-- `aslint`
-- `axe`
-- `htmlcs`
-- `ibm`
-- `testaro`
-
 ##### Configuration
 
 Every tool invoked by Testaro must have:
@@ -331,17 +308,18 @@ test: [
   'Perform a test',
   {
     which: [true, 'string', 'isTest', 'test name'],
+    launch: [false, 'object', '', 'if new browser to be launched, properties different from target, browserID, and what of the job'],
     rules: [false, 'array', 'areStrings', 'rule IDs or specifications, if not all']
     what: [false, 'string', 'hasLength', 'comment']
   }
 ],
 ```
 
-That means that a test act (i.e. an act with a `type` property having the value `'test'`) must have a string-valued `which` property naming a tool and may optionally have an array-valued `rules` property restricting the rules to be reported on and/or a string-valued `what` property describing the tool and/or the tests.
+That means that a test act (i.e. an act with a `type` property having the value `'test'`) must have a string-valued `which` property naming a tool and may optionally have an object-valued `launch` property, an array-valued `rules` property, and/or a string-valued `what` property.
 
 If a particular test act either must have or may have any other properties, those properties are specified in the `tools` property in `actSpecs.js`.
 
-When you include a `rules` property, you limit the tests of the tool that are performed or reported. For some tools (`alfa`, `axe`, `htmlcs`, `qualWeb`, and `testaro`), only the specified tests are performed. Other tools (`aslint`, `ed11y`, `ibm`, `nuVal`, and `wave`) do not allow such a limitation, so, for those tools, all tests are performed but results are reported from only the specified tests.
+When you include a `rules` property, you limit the tests of the tool that are performed or reported. For some tools (`alfa`, `axe`, `htmlcs`, `qualWeb`, `testaro`, and `wax`), only the specified tests are performed. Other tools (`aslint`, `ed11y`, `ibm`, `nuVal`, and `wave`) do not allow such a limitation, so, for those tools, all tests are performed but results are reported from only the specified tests.
 
 The `nuVal`, `qualWeb`, and `testaro` tools require specific formats for the `rules` property. Those formats are described below in the sections about those tools.
 
@@ -358,7 +336,7 @@ An example of a `test` act is:
 }
 ```
 
-Most tools allow you to decide which of their rules to apply. In effect, this means deciding which of their tests to run, since each test is considered a test of some rule. The act example given above,
+Most tools allow you to decide which of their rules to apply. In effect, this means deciding which of their tests to run, since each test is considered a test of some rule. The act example
 
 ```javaScript
 {
@@ -536,7 +514,7 @@ You can add custom rules to the rules of any tool. Testaro provides a template,
 
 #### WallyAX
 
-If a `wax` test act is included in the job, an environment variable named `WAX_KEY` must exist, with your WallyAX API key as its value. You can get it from [WallyAX](mailto:technology@wallyax.com).
+If a `wax` test act is included in the job, an environment variable named `WAX_KEY` must exist, with your WallyAX API key as its value. You can request it from [WallyAX](mailto:technology@wallyax.com).
 
 The `wax` tool imposes a limit on the size of a page to be tested. If the page exceeds the limit, Testaro treats the page as preventing `wax` from performing its tests. The limit is less than 500,000 characters.
 
@@ -629,8 +607,7 @@ Testaro also generates some data about the job and adds those data to the job, i
 ### Contents
 
 A report discloses:
-- raw results of tests conducted by tools
-- standardized results of tests conducted by tools
+- results of tests conducted by tools
 - process data, including statistics on:
     - latency (how long a time each tool takes to run its tests)
     - test prevention (the failure of tools to run on particular targets)
@@ -655,6 +632,8 @@ The standard result includes three properties:
 - `totals`: an array of numbers representing how many instances of rule violations at each level of severity the tool reported. There are 4 ordinal severity levels. For example, the array `[3, 0, 14, 10]` would report that there were 3 violations at level 0, 0 at level 1, 14 at level 2, and 10 at level 3.
 - `instances`: an array of objects describing the rule violations. An instance can describe a single violation, usually by one element in the page, or can summarize multiple violations of the same rule.
 
+If the value of `prevented` is `true`, the standard result also includes an `error` property describing the reason for the failure.
+
 ##### Instances
 
 Here is an example of a standard instance:
@@ -686,6 +665,7 @@ The element has no `id` attribute to distinguish it from other `button` elements
 - `xpath`: Alfa, ASLint, Equal Access
 - `box` (coordinates, width, and height of the element box): Editoria11y, Testaro
 - none: HTML CodeSniffer
+
 The tool also reproduces an excerpt of the element code.
 
 ##### Element identification

package/actSpecs.js

@@ -54,7 +54,7 @@ exports.actSpecs = {
     launch: [
       'Launch a Playwright browser',
       {
-        target: [false, 'object', '', 'target different from sources.target of the job'],
+        target: [false, 'object', '', 'target different from target of the job'],
         browserID: [false, 'string', 'isBrowserID', 'browser type different from browserID of the job'],
         what: [false, 'string', 'hasLength', 'comment']
       }
@@ -144,6 +144,7 @@ exports.actSpecs = {
       'Perform tests of a tool',
       {
         which: [true, 'string', 'isTest', 'tool name'],
+        launch: [false, 'object', '', 'if new browser to be launched, properties different from target, browserID, and what of the job'],
         rules: [false, 'array', 'areStrings', 'rule IDs or (for nuVal) specifications, if not all']
       }
     ],

package/package.json

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

package/procs/job.js

@@ -187,7 +187,6 @@ exports.isValidJob = job => {
     const {
       id,
       strict,
-      isolate,
       standard,
       observe,
       device,
@@ -207,9 +206,6 @@ exports.isValidJob = job => {
     if (typeof strict !== 'boolean') {
       return 'Bad job strict';
     }
-    if (typeof isolate !== 'boolean') {
-      return 'Bad job isolate';
-    }
     if (! ['also', 'only', 'no'].includes(standard)) {
       return 'Bad job standard';
     }
@@ -247,9 +243,8 @@ exports.isValidJob = job => {
     if (
       ! acts
       || ! Array.isArray(acts)
-      || acts.length < 2
+      || ! acts.length
       || ! acts.every(act => act.type && typeof act.type === 'string')
-      || acts[0].type !== 'launch'
     ) {
       return 'Bad job acts';
     }

package/procs/standardize.js

@@ -647,7 +647,7 @@ const convert = (toolName, data, result, standardResult) => {
       // Get its standard instance properties.
       const element = violation.element.replace(/\s+/g, ' ');
       const {message, description, severity} = violation;
-      const ordinalSeverity = ['Minor', 'Moderate', 'Major', 'Severe', 'Critical'].indexOf(severity);
+      const ordinalSeverity = ['Minor', 'Moderate', '', 'Severe'].indexOf(severity);
       const tagNameCandidate = element.replace(/^<| .*$/g, '');
       const tagName = /^[a-zA-Z0-9]+$/.test(tagNameCandidate) ? tagNameCandidate.toUpperCase() : '';
       let id = '';
@@ -677,8 +677,6 @@ const convert = (toolName, data, result, standardResult) => {
         location,
         excerpt: element
       };
-      // Add its ordinal severity to the standard result totals.
-      standardResult.totals[ordinalSeverity]++;
       // Add the instance to the standard result.
       standardResult.instances.push(instance);
     });

package/run.js

@@ -88,10 +88,11 @@ const timeLimits = {
 
 // Facts about the current session.
 let actCount = 0;
-// Facts about the current browser.
+// Facts about the current act.
+let actIndex = 0;
 let browser;
 let browserContext;
-let currentPage;
+let page;
 let requestedURL = '';
 
 // FUNCTIONS
@@ -192,6 +193,7 @@ const browserClose = async () => {
 };
 // Launches a browser, navigates to a URL, and returns browser data.
 const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
+  const act = report.acts[actIndex];
   const {device} = report;
   const deviceID = device && device.id;
   const browserID = tempBrowserID || report.browserID || '';
@@ -211,85 +213,76 @@ const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
     };
     browserOptions.headless = ! debug;
     browserOptions.slowMo = waits || 0;
-    // Launch the browser.
-    browser = await browserType.launch(browserOptions)
-    // If the launch failed:
-    .catch(async error => {
-      console.log(`ERROR launching browser (${error.message.slice(0, 200)})`);
-      // Return this.
-      return {
-        success: false,
-        error: 'Browser launch failed'
-      };
-    });
-    // Open a context (i.e. browser window).
-    const browserContext = await browser.newContext(device.windowOptions);
-    // Prevent default timeouts.
-    browserContext.setDefaultTimeout(0);
-    // When a page (i.e. browser tab) is added to the browser context (i.e. browser window):
-    browserContext.on('page', async page => {
-      // Ensure the report has a jobData property.
-      report.jobData ??= {};
-      const {jobData} = report;
-      jobData.logCount ??= 0;
-      jobData.logSize ??= 0;
-      jobData.errorLogCount ??= 0;
-      // Add any error events to the count of logging errors.
-      page.on('crash', () => {
-        jobData.errorLogCount++;
-        console.log('Page crashed');
-      });
-      page.on('pageerror', () => {
-        jobData.errorLogCount++;
-      });
-      page.on('requestfailed', () => {
-        jobData.errorLogCount++;
-      });
-      // If the page emits a message:
-      page.on('console', msg => {
-        const msgText = msg.text();
-        let indentedMsg = '';
-        // If debugging is on:
-        if (debug) {
-          // Log a summary of the message on the console.
-          const parts = [msgText.slice(0, 75)];
-          if (msgText.length > 75) {
-            parts.push(msgText.slice(75, 150));
-            if (msgText.length > 150) {
-              const tail = msgText.slice(150).slice(-150);
-              if (msgText.length > 300) {
-                parts.push('...');
-              }
-              parts.push(tail.slice(0, 75));
-              if (tail.length > 75) {
-                parts.push(tail.slice(75));
+    try {
+      // Replace the browser with a new one.
+      browser = await browserType.launch(browserOptions);
+      // Open a context (i.e. browser window).
+      const browserContext = await browser.newContext(device.windowOptions);
+      // Prevent default timeouts.
+      browserContext.setDefaultTimeout(0);
+      // When a page (i.e. browser tab) is added to the browser context (i.e. browser window):
+      browserContext.on('page', async page => {
+        // Ensure the report has a jobData property.
+        report.jobData ??= {};
+        const {jobData} = report;
+        jobData.logCount ??= 0;
+        jobData.logSize ??= 0;
+        jobData.errorLogCount ??= 0;
+        // Add any error events to the count of logging errors.
+        page.on('crash', () => {
+          jobData.errorLogCount++;
+          console.log('Page crashed');
+        });
+        page.on('pageerror', () => {
+          jobData.errorLogCount++;
+        });
+        page.on('requestfailed', () => {
+          jobData.errorLogCount++;
+        });
+        // If the page emits a message:
+        page.on('console', msg => {
+          const msgText = msg.text();
+          let indentedMsg = '';
+          // If debugging is on:
+          if (debug) {
+            // Log a summary of the message on the console.
+            const parts = [msgText.slice(0, 75)];
+            if (msgText.length > 75) {
+              parts.push(msgText.slice(75, 150));
+              if (msgText.length > 150) {
+                const tail = msgText.slice(150).slice(-150);
+                if (msgText.length > 300) {
+                  parts.push('...');
+                }
+                parts.push(tail.slice(0, 75));
+                if (tail.length > 75) {
+                  parts.push(tail.slice(75));
+                }
               }
             }
+            indentedMsg = parts.map(part => `    | ${part}`).join('\n');
+            console.log(`\n${indentedMsg}`);
           }
-          indentedMsg = parts.map(part => `    | ${part}`).join('\n');
-          console.log(`\n${indentedMsg}`);
-        }
-        // Add statistics on the message to the report.
-        const msgTextLC = msgText.toLowerCase();
-        const msgLength = msgText.length;
-        jobData.logCount++;
-        jobData.logSize += msgLength;
-        if (errorWords.some(word => msgTextLC.includes(word))) {
-          jobData.errorLogCount++;
-          jobData.errorLogSize += msgLength;
-        }
-        const msgLC = msgText.toLowerCase();
-        if (
-          msgText.includes('403') && (msgLC.includes('status')
-          || msgLC.includes('prohibited'))
-        ) {
-          jobData.prohibitedCount++;
-        }
+          // Add statistics on the message to the report.
+          const msgTextLC = msgText.toLowerCase();
+          const msgLength = msgText.length;
+          jobData.logCount++;
+          jobData.logSize += msgLength;
+          if (errorWords.some(word => msgTextLC.includes(word))) {
+            jobData.errorLogCount++;
+            jobData.errorLogSize += msgLength;
+          }
+          const msgLC = msgText.toLowerCase();
+          if (
+            msgText.includes('403') && (msgLC.includes('status')
+            || msgLC.includes('prohibited'))
+          ) {
+            jobData.prohibitedCount++;
+          }
+        });
       });
-    });
-    // Open the first page (tab) of the context (window).
-    const page = await browserContext.newPage();
-    try {
+      // Replace the page with the first page (tab) of the context (window).
+      page = await browserContext.newPage();
       // Wait until it is stable.
       await page.waitForLoadState('domcontentloaded', {timeout: 5000});
       // Navigate to the specified URL.
@@ -298,41 +291,44 @@ const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
       if (navResult.success) {
         // Update the name of the current browser type and store it in the page.
         page.browserID = browserID;
-        // Return the response of the target server, the browser context, and the page.
-        return {
-          success: true,
-          response: navResult.response,
-          browserContext,
-          page
-        };
+        // Add the actual URL to the act.
+        act.actualURL = page.url();
+        // Get the response of the target server.
+        const {response} = navResult;
+        // Add the script nonce, if any, to the act.
+        const scriptNonce = await getNonce(response);
+        if (scriptNonce) {
+          report.jobData.lastScriptNonce = scriptNonce;
+        }
       }
-      // Otherwise, if the navigation failed:
+      // Otherwise, i.e. if the launch or navigation failed:
       else {
-        // Return the error.
-        return {
-          success: false,
-          error: navResult.error
-        };
+        // Report this and abort the job.
+        actIndex = await addError(
+          true, true, report, actIndex, `ERROR: Launch failed (${navResult.error})`
+        );
+        page = null;
       }
     }
-    // If it fails to become stable after load:
+    // If an error occurred:
     catch(error) {
-      // Return this.
-      console.log(`ERROR: Blank page load in new tab timed out (${error.message})`);
-      return {
-        success: false,
-        error: 'Blank page load in new tab timed out'
-      };
-    }
+      // Report this and abort the job.
+      actIndex = await addError(
+        true, true, report, actIndex, `ERROR launching or navigating ${error.message}`
+      );
+      page = null;
+    };
   }
   // Otherwise, i.e. if the browser or device ID is invalid:
   else {
-    // Return this.
-    console.log(`ERROR: Browser ${browserID}, device ${deviceID}, or URL ${url} invalid`);
-    return {
-      success: false,
-      error: `${browserID} browser launch with ${deviceID} device and navigation to ${url} failed`
-    };
+    // Report this and abort the job.
+    actIndex = await addError(
+      true,
+      true,
+      report,
+      actIndex,
+      `ERROR: Browser ${browserID}, device ${deviceID}, or URL ${url} invalid`
+    );
   }
 };
 // Returns a string representing the date and time.
@@ -544,7 +540,7 @@ const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
   }
 };
 // Recursively performs the acts in a report.
-const doActs = async (report, actIndex, page) => {
+const doActs = async (report, actIndex) => {
   const {acts} = report;
   // If any more acts are to be performed:
   if (actIndex > -1 && actIndex < acts.length) {
@@ -606,34 +602,119 @@ const doActs = async (report, actIndex, page) => {
     }
     // Otherwise, if the act is a launch:
     else if (type === 'launch') {
-      // Launch the specified browser on the specified device and navigate to the specified URL.
-      const launchResult = await launch(
+      // Launch a browser, navigate to a page, and add the result to the act.
+      await launch(
         report,
         debug,
         waits,
         act.browserID || report.browserID || '',
-        act.url || report.target && report.target.url || ''
+        act.target && act.target.url || report.target && report.target.url || ''
       );
-      // If the launch and navigation succeeded:
-      if (launchResult && launchResult.success) {
-        // Get the response of the target server.
-        const {response} = launchResult;
-        // Get the target page.
-        page = launchResult.page;
-        // Add the actual URL to the act.
-        act.actualURL = page.url();
-        // Add the script nonce, if any, to the act.
-        const scriptNonce = await getNonce(response);
-        if (scriptNonce) {
-          report.jobData.lastScriptNonce = scriptNonce;
+      // If this failed:
+      if (page.prevented) {
+        // Add this to the act.
+        act.prevented = true;
+        act.error = page.error || '';
+      }
+    }
+    // Otherwise, if the act performs tests of a tool:
+    else if (act.type === 'test') {
+      // Add a description of the tool to the act.
+      act.what = tools[act.which];
+      // Get the start time of the act.
+      const startTime = Date.now();
+      try {
+        // Get the time limit in seconds for the act.
+        const timeLimit = timeLimits[act.which] || 15;
+        // If a new browser is to be launched:
+        if (act.launch) {
+          // Launch it, navigate to a URL, and replace the page.
+          await launch(
+            report,
+            debug,
+            waits,
+            act.launch.browserID || report.browserID,
+            act.launch.target && act.launch.target.url || report.target.url
+          );
+        }
+        // If the page has not prevented the tool from testing:
+        if (! page.prevented) {
+          // Perform the specified tests of the tool.
+          const actReport = await require(`./tests/${act.which}`)
+          .reporter(page, report, actIndex, timeLimit);
+          // Add the data and result to the act.
+          act.data = actReport.data;
+          act.result = actReport.result;
+          // If the tool reported that the page prevented testing:
+          if (actReport.data.prevented) {
+            // Add prevention data to the job data.
+            report.jobData.preventions[act.which] = act.data.error;
+          }
         }
       }
-      // Otherwise, i.e. if the launch or navigation failed:
-      else {
-        // Add an error result to the act and abort the job.
-        actIndex = await addError(
-          true, true, report, actIndex, `ERROR: Launch failed (${launchResult.error})`
-        );
+      // If the tool invocation failed:
+      catch(error) {
+        // Report the failure.
+        const message = error.message.slice(0, 400);
+        console.log(`ERROR: Test act ${act.which} failed (${message})`);
+        act.data.prevented = true;
+        act.data.error = act.data.error ? `${act.data.error}; ${message}` : message;
+      }
+      // Add the elapsed time of the tool to the report.
+      const time = Math.round((Date.now() - startTime) / 1000);
+      const {toolTimes} = report.jobData;
+      if (! toolTimes[act.which]) {
+        toolTimes[act.which] = 0;
+      }
+      toolTimes[act.which] += time;
+      const standard = report.standard || 'only';
+      // If the act was not prevented and standardization is required:
+      if (! act.data.prevented && ['also', 'only'].includes(standard)) {
+        // Initialize the standard result.
+        act.standardResult = {
+          totals: [0, 0, 0, 0],
+          instances: []
+        };
+        // Populate it.
+        standardize(act);
+        // Add a box ID and a path ID to each of its standard instances if missing.
+        for (const instance of act.standardResult.instances) {
+          const elementID = await identify(instance, page);
+          if (! instance.boxID) {
+            instance.boxID = elementID ? elementID.boxID : '';
+          }
+          if (! instance.pathID) {
+            instance.pathID = elementID ? elementID.pathID : '';
+          }
+        };
+        // If the original-format result is not to be included in the report:
+        if (standard === 'only') {
+          // Remove it.
+          delete act.result;
+        }
+      }
+      const expectations = act.expect;
+      // If the act was not prevented and has expectations:
+      if (! act.data.prevented && expectations) {
+        // Initialize whether they were fulfilled.
+        act.expectations = [];
+        let failureCount = 0;
+        // For each expectation:
+        expectations.forEach(spec => {
+          // Add the its result to the act.
+          const truth = isTrue(act, spec);
+          act.expectations.push({
+            property: spec[0],
+            relation: spec[1],
+            criterion: spec[2],
+            actual: truth[0],
+            passed: truth[1]
+          });
+          if (! truth[1]) {
+            failureCount++;
+          }
+        });
+        act.expectationFailures = failureCount;
       }
     }
     // Otherwise, if a current page exists:
@@ -805,91 +886,6 @@ const doActs = async (report, actIndex, page) => {
             };
           });
         }
-        // Otherwise, if the act performs tests of a tool:
-        else if (act.type === 'test') {
-          // Add a description of the tool to the act.
-          act.what = tools[act.which];
-          // Get the start time of the act.
-          const startTime = Date.now();
-          try {
-            // 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);
-            // Add the data and result to the act.
-            act.data = actReport.data;
-            act.result = actReport.result;
-            // If the tool reported that the page prevented testing:
-            if (actReport.data.prevented) {
-              // Add prevention data to the job data.
-              report.jobData.preventions[act.which] = act.data.error;
-            }
-          }
-          // If the tool invocation failed:
-          catch(error) {
-            // Report the failure.
-            const message = error.message.slice(0, 400);
-            console.log(`ERROR: Test act ${act.which} failed (${message})`);
-            act.data.prevented = true;
-            act.data.error = act.data.error ? `${act.data.error}; ${message}` : message;
-          }
-          // Add the elapsed time of the tool to the report.
-          const time = Math.round((Date.now() - startTime) / 1000);
-          const {toolTimes} = report.jobData;
-          if (! toolTimes[act.which]) {
-            toolTimes[act.which] = 0;
-          }
-          toolTimes[act.which] += time;
-          // If the act was not prevented and standardization is required:
-          const standard = report.standard || 'only';
-          if (! act.data.prevented && ['also', 'only'].includes(standard)) {
-            // Initialize it.
-            act.standardResult = {
-              totals: [0, 0, 0, 0],
-              instances: []
-            };
-            // Populate it.
-            standardize(act);
-            // Add a box ID and a path ID to each of its standard instances if missing.
-            for (const instance of act.standardResult.instances) {
-              const elementID = await identify(instance, page);
-              if (! instance.boxID) {
-                instance.boxID = elementID ? elementID.boxID : '';
-              }
-              if (! instance.pathID) {
-                instance.pathID = elementID ? elementID.pathID : '';
-              }
-            };
-            // If the original-format result is not to be included in the report:
-            if (standard === 'only') {
-              // Remove it.
-              delete act.result;
-            }
-          }
-          // If the act was not prevented and has expectations:
-          const expectations = act.expect;
-          if (! act.data.prevented && expectations) {
-            // Initialize whether they were fulfilled.
-            act.expectations = [];
-            let failureCount = 0;
-            // For each expectation:
-            expectations.forEach(spec => {
-              const truth = isTrue(act, spec);
-              act.expectations.push({
-                property: spec[0],
-                relation: spec[1],
-                criterion: spec[2],
-                actual: truth[0],
-                passed: truth[1]
-              });
-              if (! truth[1]) {
-                failureCount++;
-              }
-            });
-            act.expectationFailures = failureCount;
-          }
-        }
         // Otherwise, if the act is a move:
         else if (moves[act.type]) {
           const selector = typeof moves[act.type] === 'string' ? moves[act.type] : act.what;
@@ -995,8 +991,7 @@ const doActs = async (report, actIndex, page) => {
                   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;
+                // Add the page URL to the result.
                 act.result.newURL = page.url();
               }
             };
@@ -1337,7 +1332,7 @@ const doActs = async (report, actIndex, page) => {
     }
     act.endTime = Date.now();
     // Perform any remaining acts if not aborted.
-    await doActs(report, actIndex + 1, page);
+    await doActs(report, actIndex + 1);
   }
   // Otherwise, if all acts have been performed and the job succeeded:
   else if (! report.jobData.abortTime) {