testilo 35.2.0 → 36.0.1

package/README.md

@@ -77,11 +77,11 @@ For example, a target list might be:
 ]
 ```
 
-A target list can be represented by a text file, in which each target is specified on a line with a Tab character delimiting its description and its URL, which are not quoted. Such a file representing the above target list would have this content, where “➡︎” represents a tab character:
+A target list can be represented by a text file, in which each target is specified on a line with a Vertical Line character (`|`) delimiting its description and its URL, which are not quoted. Such a file representing the above target list would have this content:
 
 ```text
-World Wide Web Consortium➡︎https://www.w3.org/
-Mozilla Foundation➡︎https://foundation.mozilla.org/en/
+World Wide Web Consortium|https://www.w3.org/
+Mozilla Foundation|https://foundation.mozilla.org/en/
 ```
 
 ### Batches
@@ -92,17 +92,15 @@ Targets can be specified in a more complex way, too. That allows you to create j
 {
   id: 'clothing-stores',
   what: 'clothing stores',
-  targets: [
-    {
-      id: 'acme',
+  targets: {
+    acme: {
       what: 'Acme Clothes',
-      which: 'https://acmeclothes.com/',
-      acts: {
+      url: 'https://acmeclothes.com/',
+      actGroups: {
         public: [
           {
             type: 'launch',
             what: 'Acme Clothes home page',
-            url: 'https://acmeclothes.com/'
           }
         ],
         private: [
@@ -139,10 +137,54 @@ Targets can be specified in a more complex way, too. That allows you to create j
 }
 ```
 
-As shown, a batch, unlike a target list, defines named sequences of acts. They can be plugged into jobs, so various complex operations can be performed on each target.
+As shown, a batch, unlike a target list, defines named groups of acts. They can be substituted for script placeholders, so various complex operations can be performed on each target.
+
+In this example, the `public` act group contains only 1 act, of type `launch`. A `launch` act in an act group is permitted to have only two properties, `what` and `url`. If either of these is omitted, its value is inherited from the corresponding property of the target. In the `public` act group in this case, the `what` value is specified, but the `url` value will be `https://acmeclothes.com/`, inherited from the target.
 
 A batch is a JavaScript object. It can be converted to JSON and stored in a file.
 
+### Target list to batch
+
+If you have a target list, the `batch` module of Testilo can convert it to a simple batch. The batch will contain, for each target, only one act group, named `main`, containing only a `launch` act. The target’s entry in the target list will determine the `what` and `url` properties of the target, and the `launch` acts will not override the values of those properties.
+
+#### Invocation
+
+There are two ways to use the `batch` module.
+
+##### By a module
+
+A module can invoke `batch()` in this way:
+
+```javaScript
+const {batch} = require('testilo/batch');
+const id = 'divns';
+const what = 'divisions';
+const targets = [
+  ['Energy', 'https://abc.com/energy'],
+  ['Water', 'https://abc.com/water']
+];
+const batchObj = batch(id, what, targets);
+```
+
+The `id` argument to `batch()` is an identifier for the target list. The `what` variable describes the target list. The `targets` variable is an array of arrays, with each array containing the 2 items (description and URL) defining one target.
+
+The `batch()` function of the `batch` module generates a batch and returns it as an object. Within the batch, each target is given a sequential (base-62 alphanumeric) string as an ID.
+
+The invoking module can further dispose of the batch as needed.
+
+##### By a user
+
+A user can invoke `batch()` in this way:
+
+- Create a target list and save it as a text file (with Vertical-Line-delimited items in Newline-delimited lines) in the `targetLists` subdirectory of the `SPECDIR` directory. Name the file `x.txt`, where `x` is the list ID.
+- In the Testilo project directory, execute the statement `node call batch id what`.
+
+In this statement, replace `id` with the list ID and `what` with a string describing the batch. Example: `node call batch divns 'ABC company divisions'`.
+
+The `call` module will retrieve the named target list.
+The `batch` module will convert the target list to a batch.
+The `call` module will save the batch as a JSON file named `x.json` (replacing `x` with the list ID) in the `batches` subdirectory of the `SPECDIR` directory.
+
 ### Scripts
 
 The generic, target-independent description of a job is _script_. A script can contain _placeholders_ that Testilo replaces with acts from a batch, creating one job per target. Thus, one script plus a batch containing _n_ targets will generate _n_ jobs.
@@ -155,12 +197,32 @@ Here is a script:
   what: 'aside mislocation',
   strict: true,
   isolate: true,
-  timeLimit: 60,
+  standard: 'also',
+  observe: false,
+  deviceID: 'Kindle Fire HDX',
+  browserID: 'webkit',
+  lowMotion: false,
+  timeLimit: 80,
+  creationTimeStamp: ''
+  executionTimeStamp: '',
+  sources: {
+    script: 'ts99',
+    batch: '',
+    target: {
+      what: '',
+      url: ''
+    },
+    lastTarget: false,
+    mergeID: '',
+    sendReportTo: 'https://abccorp.com/api/report',
+    requester: 'anama@abccorp.com'
+  },
   acts: [
     {
       type: 'placeholder',
       which: 'private',
-      launch: 'chromium'
+      deviceID: 'default',
+      browserID: 'chromium'
     },
     {
       type: 'test',
@@ -181,58 +243,25 @@ Here is a script:
 ```
 
 A script has several properties that specify facts about the jobs to be created. They include:
-- `id`: an ID. A script can be converted from a JavaScript object to JSON and saved in a file in the `SPECDIR` directory, where it will be named by its ID (e.g., if the ID is `ts99`, the file name will be `ts99.json`). Thus, each script needs an `id` with a unique value.
+- `id`: an ID. A script can be converted from a JavaScript object to JSON and saved in a file in the `SPECDIR` directory, where it will be named by its ID (e.g., if the ID is `ts99`, the file name will be `ts99.json`). Each script needs an `id` with a unique value composed of alphanumeric ASCII characters.
 - `what`: a description of the script.
 - `strict`: `true` if Testaro is to abort jobs when a target redirects a request to a URL differing substantially from the one specified. If `false` Testaro is to allow redirection. All differences are considered substantial unless the URLs differ only in the presence and absence of a trailing slash.
 - `isolate`: If `true`, Testilo, before creating a job, will isolate test acts, as needed, from effects of previous test acts, by inserting a copy of the latest placeholder after each target-modifying test act other than the final act. If `false`, placeholders will not be duplicated.
+- `standard`: When Testaro performs a job, every tool produces its own report. Testaro can convert the test results of each tool report to standard results. The `standard` property specifies how to handle standardization. If `also`, Testaro will include in its reports both the original results of the tests of tools and the Testaro-standardized results. If `only`, reports will include only the standardized test results. If `no`, reports will include only the original results, without standardization.
+- `observe`: Testaro jobs can allow granular observation. If `true`, the job will do so. If `false`, Testaro will not report job progress, but will send a report to the server only when the report is completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes a few minutes.
 - `timeLimit`: This specifies the maximum duration, in seconds, of a job. Testaro will abort jobs that are not completed within that time.
+- `deviceID`: This specifies the default device type of the job.
+- `browserID`: This specifies the default browser type (`'chromium'`, `'firefox'`, or `'webkit'`) of the job.
+- `lowMotion`: This is true if the browser is to create tabs with the `reduce-motion` option set to `reduce` instead of `no-preference`. This makes the browser act as if the user has chosen a [motion-reduction option in the settings of the operating system or browser](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion#user_preferences). Motions on pages are, however, often immune to this setting.
+- `creationTimeStamp` and `executionTimeStamp`: These properties will have values assigned to them when jobs are created from the script.
+- `sources.script`: This preserves the ID of the script after the `id` property is replaced with a job ID.
+- `sources.sendReportTo`: This (if not `''`) is the URL to which a Testaro agent is to send its report after it performs a job derived from the script.
+- `sources.requester`: This is the email address to which a message announcing the completion of the job is to be sent, if any.
 - `acts`: an array of acts.
 
-The first act in this example script is a placeholder, whose `which` property is `'private'`. If the above batch were merged with this script, in each job the placeholder would be replaced with the `private` acts of a target. For example, the first act of the first job would launch a Chromium browser, navigate to the Acme login page, complete and submit the login form, wait for the account page to load, run the Axe tests, and then run the QualWeb tests. If the batch contained additional targets, additional jobs would be created, with the login actions for each target specified in the `private` array of the `acts` object of that target.
+In this example, the script contains 3 acts, of which the first is a placeholder. If the above batch were merged with this script, in each job the placeholder would be replaced with the acts in the `private` act group of a target. For example, the first act of the first job would launch a Chromium browser on a default device, navigate to the Acme login page, complete and submit the login form, wait for the account page to load, run the Axe tests, and then run the QualWeb tests. If the batch contained additional targets, additional jobs would be created, with the acts for each target specified by the `private` property of the `actGroups` object of that target.
 
-As shown in this example, when a browser is launched by placeholder substitution, the script can determine the browser type (`chromium`, `firefox`, or `webkit`) by assigning a value to a `launch` property of the placeholder. This allows a script to ensure that the tests it requires are performed with appropriate browser types. Some browser types are incompatible with some tests.
-
-### Target list to batch
-
-If you have a target list, the `batch` module of Testilo can convert it to a simple batch. The batch will contain, for each target, only one array of acts, named `main`, containing only a `launch` act (depending on the script to specify the browser type and depending on the target to specify the URL).
-
-#### Invocation
-
-There are two ways to use the `batch` module.
-
-##### By a module
-
-A module can invoke `batch()` in this way:
-
-```javaScript
-const {batch} = require('testilo/batch');
-const id = 'divns';
-const what = 'divisions';
-const targets = [
-  ['Energy', 'https://abc.com/energy'],
-  ['Water', 'https://abc.com/water']
-];
-const batchObj = batch(id, what, targets);
-```
-
-The `id` argument to `batch()` is a unique identifier for the target list. The `what` variable describes the target list. The `targets` variable is an array of arrays, with each array containing the 2 items (description and URL) defining one target.
-
-The `batch()` function of the `batch` module generates a batch and returns it as an object. Within the batch, each target is given a sequential (base-62 alphanumeric) string as an ID.
-
-The invoking module can further dispose of the batch as needed.
-
-##### By a user
-
-A user can invoke `batch()` in this way:
-
-- Create a target list and save it as a text file (with tab-delimited items in newline-delimited lines) in the `targetLists` subdirectory of the `SPECDIR` directory. Name the file `x.txt`, where `x` is the list ID.
-- In the Testilo project directory, execute the statement `node call batch id what`.
-
-In this statement, replace `id` with the list ID and `what` with a string describing the batch. Example: `node call batch divns 'ABC company divisions'`.
-
-The `call` module will retrieve the named target list.
-The `batch` module will convert the target list to a batch.
-The `call` module will save the batch as a JSON file named `x.json` (replacing `x` with the list ID) in the `batches` subdirectory of the `SPECDIR` directory.
+As shown in this example, it is possible for any particular placeholder to override the default device type and/or browser type of the script by having its own optional `deviceID` and/or `browserID` property. Some rules are particularly relevant to some device types and/or can be successfully tested only with particular browser types. Overriding the default device and browser types lets you handle such constraints.
 
 ### Script creation
 
@@ -277,9 +306,11 @@ For an issue restriction, it has this structure:
 
 If you specify tool options, the script will prescribe the tests for all evaluation rules of the tools that you specify.
 
-If you specify issue options, the script will prescribe the tests for all evaluation rules that are classified in the issues whose IDs you specify. Any tools that do not have any of those rules will be omitted. The value of `specs/issues` is an issue classification object, with a structure like the one in `procs/score/tic40.js`. That one classifies about 1000 rules into about 300 issues.
+If you specify issue options, the script will prescribe the tests for all evaluation rules that are classified into the issues whose IDs you specify. Any tools that do not have any of those rules will be omitted. The value of `specs.issues` is an issue classification object, with a structure like the one in `procs/score/tic43.js`. That one classifies about 1000 rules into about 300 issues.
 
-For example, one issue in the `tic40.js` file is `mainNot1`. Four rules are classified as belonging to that issue: rule `main_element_only_one` of the `aslint` tool and 3 more rules defined by 3 other tools. You can also create custom classifications and save them in a `score` subdirectory of the `FUNCTIONDIR` directory.
+For example, one issue in the `tic43.js` file is `mainNot1`. Four rules are classified as belonging to that issue: rule `main_element_only_one` of the `aslint` tool and 3 more rules defined by 3 other tools. You can also create custom classifications and save them in a `score` subdirectory of the `FUNCTIONDIR` directory.
+
+The `script()` function will populate the `sources.sendReportTo` property with the value, if any, of the environment variable `SEND_REPORT_TO`, and populate the `sources.requester` property with the value, if any, of the environment variable `REQUESTER`.
 
 #### Invocation
 
@@ -318,19 +349,34 @@ The first form will create a script with no restrictions.
 
 The second form will create a script that prescribes tests for all the rules of the specified tools.
 
-The third form will create a script that prescribes tests for all the rules classified by the specified issue classification into any of the specified issues.
+The third form will create a script that prescribes tests for all the rules classified by the named issue-classification file into any of the specified issues.
 
-In this statement, replace `id` with an ID for the script, such as `headings1`, consisting of ASCII alphanumeric characters.
+In this statement, replace `id` with an ID for the script, such as `headings1`, consisting of ASCII alphanumeric characters, or with `''` if you want Testilo to create an ID. Replace `what` with a string describing the script, or with `''` if you want Testilo to create a generic description.
 
 The `call` module will retrieve the named classification, if any.
 The `script` module will create a script.
 The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory, using the `id` value as the base of the file name.
 
-#### Options
+#### Properties
+
+When the `script` module creates a script for you, it does not ask you for all of the property values that the script may require. Instead, it chooses these default values:
+- `strict`: `false`
+- `isolate`: `true`
+- `standard`: `'only'`
+- `observe`: `false`
+- `deviceID`: `'default'`
+- `browserID`: `'webkit'`
+- `lowMotion`: `false`
+- `timeLimit`: 50 plus 30 per tool
+- `axe` test act: `detailLevel` = 2
+- `ibm` test act: `withItems` = `true`, `withNewContent` = `false`
+- `qualWeb` test act: `withNewContent` = `false`
+- `testaro` test act: `withItems` = true, `stopOnFail` = `false`
+- `wave` test act: `reportType` = 4
 
-The `script` module will use the value of the `SEND_REPORT_TO` environment variable as the value of the `sendReportTo` property of the script, if that variable exists, and otherwise will leave that property with an empty-string value.
+The `webkit` browser type is selected because the other browser types corrupt some tests. The `ibm` test is performed on the existing page content because some targets cause HTTP2 protocol errors when the `ibm` tool tries to visit them.
 
-When the `script` module creates a script for you, it does not ask you for all of the other options that the script may require. Instead, it chooses default options. For example, it sets the values of `isolate` and `strict` to `true`, and it sets the `withNewContent` property of the `ibm` tool to `false` to prevent occasional infinite loops or crashes when targets cause HTTP2 protocol errors. After you invoke `script`, you can edit the script that it creates to revise options.
+After you invoke `script`, you can edit the script that it creates to revise any of these options.
 
 ### Merge
 
@@ -348,26 +394,13 @@ A module can invoke `merge()` in this way:
 const {merge} = require('testilo/merge');
 const script = …;
 const batch = …;
-const standard = 'only';
-const observe = false;
-const requester = 'me@mydomain.tld';
 const timeStamp = '241215T1200';
-const jobs = merge(script, batch, standard, observe, requester, timeStamp, deviceID);
+const jobs = merge(script, batch, timeStamp);
 ```
 
 The first two arguments are a script and a batch obtained from files or from prior calls to `script()` and `batch()`.
 
-The `standard` argument specifies how to handle standardization. If `also`, jobs will tell Testaro to include in its reports both the original results of the tests of tools and the Testaro-standardized results. If `only`, reports are to include only the standardized test results. If `no`, reports are to include only the original results, without standardization.
-
-The `observe` argument tells Testaro whether the jobs should allow granular observation. If `true`, it will. If `false`, Testaro will not report job progress, but will send reports to the server only when the reports are completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes a few minutes.
-
-The `requester` argument is an email address to which any notices about the job are to be sent.
-
-The `timeStamp` argument specifies the earliest UTC date and time when the jobs may be assigned, or it may be an empty string if now.
-
-The `deviceID` argument specifies the ID of the test device. It must be either `'default'` or the ID of one of the test devices recognized by Playwright, published at `https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/server/deviceDescriptorsSource.json`.
-
-The `merge()` function returns the jobs in an array. The invoking module can further dispose of the jobs as needed.
+The `merge()` function returns an array of jobs, one job per target in the batch. The invoking module can further dispose of the jobs as needed.
 
 ##### By a user
 
@@ -378,13 +411,13 @@ A user can invoke `merge()` in this way:
 - In the Testilo project directory, execute the statement:
 
 ```javascript
-node call merge scriptID batchID standard observe requester timeStamp deviceID todoDir
+node call merge scriptID batchID executionTimeStamp todoDir
 ```
 
 In this statement, replace:
 - `scriptID` with the ID (which is also the base of the file name) of the script.
 - `batchID` with the ID (which is also the base of the file name) of the batch.
-- `standard`, `observe`, `requester`, `timeStamp`, and `deviceID` as described above.
+- `executionTimeStamp` with a time stamp in format `yymmddThhMM` representing the UTC date and time before which the jobs are not to be executed, or `''` if it is now.
 - `todoDir`: `true` if the jobs are to be saved in the `todo` subdirectory, or `false` if they are to be saved in the `pending` subdirectory, of the `JOBDIR` directory.
 
 The `call` module will retrieve the named script and batch from their respective directories.
@@ -393,61 +426,28 @@ The `call` module will save the jobs as JSON files in the `todo` or `pending` su
 
 #### Output
 
-A Testaro job produced by `merge` may look like this:
+A Testaro job produced by `merge` will be identical to the script from which it was derived (see the example above), except that:
+- The `id` property of the job will be revised to uniquely identify the job.
+- The originally empty properties will be populated, as in this example:
 
-```javaScript
-{
-  id: '240115T1200-4R-0',
-  what: 'aside mislocation',
-  strict: true,
-  timeLimit: 60,
-  standard: 'also',
-  observe: false,
-  sendReportTo: 'https://ourdomain.com/testman/api/report'
-  timeStamp: '240115T1200',
-  acts: [
-    {
-      type: 'launch',
-      which: 'webkit',
-      what: 'Acme Clothes',
-      deviceID: 'Galaxy S8',
-      url: 'https://acmeclothes.com/'
-    },
-    {
-      type: 'test',
-      which: 'axe',
-      detailLevel: 2,
-      rules: ['landmark-complementary-is-top-level'],
-      what: 'Axe'
-    },
-    {
-      type: 'launch',
-      which: 'webkit',
-      what: 'Acme Clothes',
-      deviceID: 'Galaxy S8',
-      url: 'https://acmeclothes.com/'
-    },
-    {
-      type: 'test',
-      which: 'qualWeb',
-      withNewContent: false,
-      rules: ['QW-BP25', 'QW-BP26']
-      what: 'QualWeb'
-    }
-  ],
-  sources: {
-    script: 'ts99',
-    batch: 'clothing-stores',
-    lastTarget: false,
-    target: {
-      id: 'acme',
-      what: 'Acme Clothes'
+    ```javaScript
+    …
+    creationTimeStamp: '241229T0537',
+    executionTimeStamp: '250110T1200',
+    sources: {
+      script: 'ts99',
+      batch: 'departments',
+      mergeID: '7f',
+      sendReportTo: 'https://abccorp.com/api/report',
+      requester: 'malavu@abccorp.com'
+      target: {
+        what: 'Real Estate Management',
+        url: 'https://abccorp.com/mgmt/realproperty.html'
+      },
+      lastTarget: false,
     },
-    requester: 'you@yourdomain.tld'
-  },
-  creationTimeStamp: '241120T1550'
-}
-```
+    …
+    ```
 
 #### Validation
 
@@ -472,6 +472,7 @@ Thus, a report produced by Testaro contains these properties:
 - `timeStamp`
 - `acts`
 - `sources`
+- `timeStamp`
 - `creationTimeStamp`
 - `jobData`
 

package/batch.js

@@ -25,10 +25,6 @@
   Converts a target list to a batch.
 */
 
-// IMPORTS
-
-const {alphaNumOf} = require('./procs/util');
-
 // FUNCTIONS
 
 // Converts a target list to a batch and returns the batch.
@@ -51,25 +47,21 @@ exports.batch = (id, what, targetList) => {
     const batch = {
       id,
       what,
-      targets: []
+      targets: {}
     };
     // For each target:
-    targetList.forEach((target, index) => {
+    targetList.forEach(target => {
       // Add it to the batch.
-      batch.targets.push({
-        id: alphaNumOf(index),
-        what: target[0],
-        which: target[1],
-        acts: {
+      batch.targets[target[0]] = {
+        url: target[1],
+        actGroups: {
           main: [
             {
-              type: 'launch',
-              what: target[0],
-              url: target[1]
+              type: 'launch'
             }
           ]
         }
-      });
+      };
     });
     // Return the batch.
     return batch;

package/call.js

@@ -186,8 +186,8 @@ const callScript = async (scriptID, what, optionType, ... optionDetails) => {
       return;
     }
   }
-  // Create a script.
-  const scriptObj = script(scriptID, what, optionArg);
+  // Create a script with default device and browser IDs.
+  const scriptObj = script(scriptID, undefined, undefined, what, optionArg);
   try {
     // Save it.
     const scriptJSON = JSON.stringify(scriptObj, null, 2);
@@ -203,18 +203,14 @@ const callScript = async (scriptID, what, optionType, ... optionDetails) => {
 const callMerge = async (
   scriptID,
   batchID,
-  standard,
-  observe,
-  requester,
-  timeStamp,
-  deviceID,
+  executionTimeStamp,
   todoDir
 ) => {
   try {
     // If the todoDir argument is invalid:
     if (! ['true', 'false'].includes(todoDir)) {
       // Report this.
-      throw new Error('Invalid todoDir configuration');
+      throw new Error('Invalid todoDir argument to merge');
     }
     // Get the script and the batch.
     const scriptJSON = await fs.readFile(`${specDir}/scripts/${scriptID}.json`, 'utf8');
@@ -222,18 +218,18 @@ const callMerge = async (
     const batchJSON = await fs.readFile(`${specDir}/batches/${batchID}.json`, 'utf8');
     const batch = JSON.parse(batchJSON);
     // Merge them into an array of jobs.
-    const jobs = merge(script, batch, standard, observe === 'true', requester, timeStamp, deviceID);
+    const jobs = merge(script, batch, executionTimeStamp);
     // Save the jobs.
     const subdir = `${jobDir}/${todoDir === 'true' ? 'todo' : 'pending'}`;
     for (const job of jobs) {
       const jobJSON = JSON.stringify(job, null, 2);
       await fs.writeFile(`${subdir}/${job.id}.json`, `${jobJSON}\n`);
     }
-    const truncatedID = `${jobs[0].timeStamp}-${jobs[0].mergeID}-…`;
+    const truncatedID = `${jobs[0].id.replace(/[^-]+$/, '')}…`;
     console.log(`Script ${scriptID} and batch ${batchID} merged as ${truncatedID} in ${subdir}`);
   }
   catch(error) {
-    console.log(`ERROR merging script and batch (${error.message})`);
+    console.log(`ERROR merging script ${scriptID} and batch ${batchID} (${error.message})`);
   }
 };
 // Gets the file base names (equal to the IDs) of the selected reports.
@@ -499,7 +495,7 @@ else if (fn === 'script' && (fnArgs.length === 2 || fnArgs.length > 3)) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'merge' && fnArgs.length === 8) {
+else if (fn === 'merge' && fnArgs.length === 4) {
   callMerge(... fnArgs)
   .then(() => {
     console.log('Execution completed');

package/merge.js

@@ -30,7 +30,7 @@
 // Module to keep secrets.
 require('dotenv').config();
 // Utility module.
-const {alphaNumOf, dateOf, getRandomString, getNowStamp, isValidDeviceID} = require('./procs/util');
+const {alphaNumOf, dateOf, getRandomString, getNowStamp} = require('./procs/util');
 
 // ########## CONSTANTS
 
@@ -49,60 +49,31 @@ const mergeIDLength = 2;
 // ########## FUNCTIONS
 
 // Merges a script and a batch and returns jobs.
-exports.merge = (script, batch, standard, observe, requester, timeStamp, deviceID) => {
-  // If standard is invalid:
-  if (! ['also', 'only', 'no'].includes(standard)) {
-    // Report this and quit.
-    console.log('ERROR: Invalid standard treatment specified');
-    return [];
-  }
-  // If observe is invalid:
-  if (! [true, false].includes(observe)) {
-    // Report this and quit.
-    console.log('ERROR: Invalid observe configuration specified');
-    return [];
-  }
+exports.merge = (script, batch, executionTimeStamp) => {
   // If a time stamp was specified:
-  if (timeStamp) {
+  if (executionTimeStamp) {
     // If it is invalid:
-    if (! dateOf(timeStamp)) {
+    if (! dateOf(executionTimeStamp)) {
       // Report this and quit.
-      console.log('ERROR: Timestamp invalid');
+      console.log('ERROR: Execution time stamp invalid');
       return [];
     }
   }
   // Otherwise, i.e. if no time stamp was specified:
   else {
     // Create one for the job.
-    timeStamp = getNowStamp();
+    executionTimeStamp = getNowStamp();
   }
-  // If deviceID is invalid:
-  if (! isValidDeviceID(deviceID)) {
-    // Report this and quit.
-    console.log('ERROR: Device ID invalid');
-    return [];
-  }
-  // Initialize a job as a copy of the script.
+  // Initialize a job template as a copy of the script.
   const protoJob = JSON.parse(JSON.stringify(script));
-  // Add an initialized sources property to it.
-  protoJob.sources = {
-    script: script.id,
-    batch: batch.id,
-    lastTarget: false,
-    target: {
-      id: '',
-      what: '',
-      which: ''
-    },
-    requester
-  };
-  // Add properties to the job.
-  protoJob.standard = standard;
-  protoJob.observe = observe;
-  protoJob.timeStamp = timeStamp;
+  // Populate empty properties of the template.
   protoJob.creationTimeStamp = getNowStamp();
+  protoJob.executionTimeStamp = executionTimeStamp;
+  const {sources} = protoJob;
+  sources.batch = batch.id;
+  sources.mergeID = getRandomString(mergeIDLength);
   // If isolation was requested:
-  if (script.isolate) {
+  if (protoJob.isolate) {
     // For each act:
     let {acts} = protoJob;
     let lastPlaceholder = {};
@@ -124,63 +95,55 @@ exports.merge = (script, batch, standard, observe, requester, timeStamp, deviceI
         acts[actIndex] = JSON.parse(JSON.stringify([act, lastPlaceholder]));
       }
     };
-    // Flatten the acts.
+    // Flatten the acts, causing insertion of placeholder copies before acts needing them.
     protoJob.acts = acts.flat();
   }
-  // Delete the no-longer-necessary job property.
-  delete protoJob.isolate;
   // Initialize an array of jobs.
   const jobs = [];
-  // Get an ID for the merger.
-  const mergeID = getRandomString(mergeIDLength);
   // For each target in the batch:
   const {targets} = batch;
-  targets.forEach((target, index) => {
+  const targetIDs = Object.keys(targets);
+  targetIDs.forEach((what, index) => {
     // If the target has the required identifiers:
-    const {id, what, which} = target;
-    if (id && what && which) {
+    const {actGroups, url} = targets[what];
+    if (actGroups && url) {
       // Initialize a job.
       const job = JSON.parse(JSON.stringify(protoJob));
+      const {sources} = job;
       // Make the job ID unique.
-      const targetID = alphaNumOf(index);
-      job.id = `${timeStamp}-${mergeID}-${targetID}`;
-      // Add other properties to the job.
-      job.mergeID = mergeID;
-      job.sendReportTo = process.env.SEND_REPORT_TO || '';
+      const targetSuffix = alphaNumOf(index);
+      job.id = `${executionTimeStamp}-${sources.mergeID}-${targetSuffix}`;
       // If the target is the last one:
-      if (index === targets.length - 1) {
+      if (index === targetIDs.length - 1) {
         // Add that fact to the sources property of the job.
-        job.sources.lastTarget = true;
+        sources.lastTarget = true;
       }
-      // Add other data to the sources property of the job.
-      job.sources.target.id = targetID;
-      job.sources.target.what = target.what;
-      job.sources.target.which = target.which;
-      // Replace each placeholder object in the job with the named replacer array of the target.
+      // Populate the target-specific properties of the job.
+      sources.target.what = what;
+      sources.target.url = url;
+      // Replace each placeholder object in the job with the named act group of the target.
       let {acts} = job;
       for (const actIndex in acts) {
         const act = acts[actIndex];
         if (act.type === 'placeholder') {
           const replacerName = act.which;
-          if (replacerName && target.acts) {
-            let replacerActs = target.acts[replacerName];
-            if (replacerActs) {
-              // Add properties to any launch act in the replacer.
-              replacerActs = JSON.parse(JSON.stringify(replacerActs));
-              for (const replacerAct of replacerActs) {
-                if (replacerAct.type === 'launch') {
-                  replacerAct.which = act.launch;
-                  replacerAct.deviceID = deviceID;
+          const replacerActs = actGroups[replacerName];
+          if (replacerName && actGroups && replacerActs) {
+            // Add properties to any launch act in the replacer.
+            for (const replacerAct of replacerActs) {
+              if (replacerAct.type === 'launch') {
+                if (act.deviceID) {
+                  replacerAct.deviceID = act.deviceID;
+                }
+                if (act.browserID) {
+                  replacerAct.browserID = act.browserID;
                 }
               }
-              acts[actIndex] = replacerActs;
-            }
-            else {
-              console.log(`ERROR: Target ${target.id} has no ${replacerName} replacer`);
-            }
+            };
+            acts[actIndex] = replacerActs;
           }
           else {
-            console.log(`ERROR: Placeholder for target ${target.id} not replaceable`);
+            console.log(`ERROR: Placeholder for target ${what} not replaceable`);
           }
         }
       }
@@ -190,7 +153,7 @@ exports.merge = (script, batch, standard, observe, requester, timeStamp, deviceI
       jobs.push(job);
     }
     else {
-      console.log('ERROR: Target in batch missing id, what, or which property');
+      console.log(`ERROR: Target ${what} in batch missing actGroups or url property`);
     }
   });
   return jobs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testilo",
-  "version": "35.2.0",
+  "version": "36.0.1",
   "description": "Prepares Testaro jobs and processes Testaro reports",
   "main": "call.js",
   "scripts": {

package/procs/digest/tdp43e/index.html

@@ -20,10 +20,18 @@
           <caption>Synopsis</caption>
           <tr><th>Page</th><td>__org__</td></tr>
           <tr><th>URL</th><td>__url__</td></tr>
-          <tr><th>Requester</th><td>__requester__</td></tr>
-          <tr><th>Device</th><td>__device__</td></tr>
           <tr><th>Test date</th><td>__dateSlash__</td></tr>
           <tr><th>Score</th><td>__total__</td></tr>
+        </table>
+        <table class="allBorder">
+          <caption>Configuration</caption>
+          <tr><th>Redirections</th><td>__redirections__</td></tr>
+          <tr><th>Tool isolation</th><td>__isolation__</td></tr>
+          <tr><th>Report format(s)</th><td>__standard__</td></tr>
+          <tr><th>Requester</th><td>__requester__</td></tr>
+          <tr><th>Device</th><td>__device__</td></tr>
+          <tr><th>Browser type</th><td>__browser__</td></tr>
+          <tr><th>Reduced motion</th><td>__motion__</td></tr>
           <tr><th>Tested by</th><td>Testaro__agent__, procedure <code>__ts__</code></td></tr>
           <tr><th>Scored by</th><td>Testilo, procedure <code>__sp__</code></td></tr>
           <tr><th>Digested by</th><td>Testilo, procedure <code>__dp__</code></td></tr>

package/procs/digest/tdp43e/index.js

@@ -57,7 +57,7 @@ const getIssueScoreRow = (issueConstants, issueDetails) => {
 };
 // Adds parameters to a query for a digest.
 const populateQuery = (report, query) => {
-  const {acts, id, sources, score} = report;
+  const {browserID, deviceID, id, isolate, lowMotion, score, sources, standard, strict} = report;
   const {agent, script, target, requester} = sources;
   const {scoreProcID, summary, details} = score;
   query.ts = script;
@@ -67,16 +67,16 @@ const populateQuery = (report, query) => {
   query.dateISO = getNowDate();
   query.dateSlash = getNowDateSlash();
   query.org = target.what;
-  query.url = target.which;
+  query.url = target.url;
+  query.redirections = strict ? 'prohibited' : 'permitted';
+  query.isolation = isolate ? 'yes' : 'no';
+  query.standard
+  = ['original', 'standard', 'original and standard'][['no', 'only', 'also'].indexOf(standard)];
+  query.motion = lowMotion ? 'requested' : 'not requested';
   query.requester = requester;
-  const firstLaunch = acts.find(act => act.type === 'launch');
-  if (firstLaunch) {
-    query.device = firstLaunch.deviceID || 'unknown';
-  }
-  else {
-    query.device = 'unknown';
-  }
-  query.agent = ` on agent ${agent}` || '';
+  query.device = deviceID;
+  query.browser = browserID;
+  query.agent = agent ? ` on agent ${agent}` : '';
   query.reportURL = process.env.SCORED_REPORT_URL.replace('__id__', id);
   // Add values for the score-summary table to the query.
   const rows = {

package/procs/track/ttp40/index.js

@@ -77,7 +77,7 @@ const populateQuery = async (id, what, summaryReport, query) => {
     const scoreCell = `<td><a href=${digestLinkDestination}>${result.score}</a></td>`;
     // Create a target cell.
     const {target} = result.sources;
-    const targetLink = `<a href="${target.which}">${target.what}</a>`;
+    const targetLink = `<a href="${target.url}">${target.what}</a>`;
     const targetCell = `<td>${targetIDs[target.what]}: ${targetLink}</td>`;
     const row = `<tr>${[timeCell, scoreCell, targetCell].join('')}</tr>`;
     // Add the row to the array of rows.

package/script.js

@@ -111,18 +111,35 @@ exports.script = (id, what, options = {}) => {
     });
   }
   // Initialize a script.
-  const timeLimit = Math.round(50 + 30 * Object.keys(toolsRulesData).length);
   const scriptObj = {
     id,
     what,
-    strict: true,
+    strict: false,
     isolate: true,
-    timeLimit,
-    acts: [
+    standard: 'only',
+    observe: false,
+    deviceID: 'default',
+    browserID: 'webkit',
+    lowMotion: false,
+    timeLimit: Math.round(50 + 30 * Object.keys(toolsRulesData).length),
+    creationTimeStamp: '',
+    executionTimeStamp: '',
+    sources: {
+      script: id,
+      batch: '',
+      target: {
+        what: '',
+        url: ''
+      },
+      lastTarget: false,
+      mergeID: '',
+      sendReportTo: process.env.SEND_REPORT_TO || '',
+      requester: process.env.REQUESTER || ''
+    },
+      acts: [
       {
-        "type": "placeholder",
-        "which": "main",
-        "launch": "webkit"
+        type: 'placeholder',
+        which: 'main'
       }
     ]
   };