testilo 23.0.0 → 24.0.0

package/README.md

@@ -65,8 +65,7 @@ Testilo can, however, make job preparation more efficient in these scenarios:
 
 The simplest version of a list of targets is a _target list_. It is an array of arrays defining 1 or more targets. It can be stored as a tab-delimited text file.
 
-A target is defined by 3 items:
-- An ID
+A target is defined by 2 items:
 - A description
 - A URL
 
@@ -74,16 +73,16 @@ For example, a target list might be:
 
 ```javaScript
 [
-  ['w3c', 'World Wide Web Consortium', 'https://www.w3.org/'],
-  ['moz', 'Mozilla Foundation', 'https://foundation.mozilla.org/en/']
+  ['World Wide Web Consortium', 'https://www.w3.org/'],
+  ['Mozilla Foundation', 'https://foundation.mozilla.org/en/']
 ]
 ```
 
 If this target list were stored as a file, its content would be this (with “→” representing the Tab character):
 
 ```text
-w3c→World Wide Web Consortium→https://www.w3.org/
-moz→Mozilla Foundation→https://foundation.mozilla.org/en/
+World Wide Web Consortium→https://www.w3.org/
+Mozilla Foundation→https://foundation.mozilla.org/en/
 ```
 
 ### Batches
@@ -97,27 +96,21 @@ Targets can be specified in a more complex way, too. That allows you to create j
   targets: [
     {
       id: 'acme',
-      which: 'https://acmeclothes.com/',
       what: 'Acme Clothes',
+      which: 'https://acmeclothes.com/',
       acts: {
         public: [
           {
-            type: 'launch'
-          },
-          {
-            type: 'url',
-            which: 'https://acmeclothes.com/',
-            what: 'Acme Clothes home page'
+            type: 'launch',
+            what: 'Acme Clothes home page',
+            url: 'https://acmeclothes.com/'
           }
         ],
         private: [
           {
-            type: 'launch'
-          },
-          {
-            type: 'url',
-            which: 'https://acmeclothes.com/login.html',
-            what: 'Acme Clothes login page'
+            type: 'launch',
+            what: 'Acme Clothes login page',
+            url: 'https://acmeclothes.com/login.html'
           },
           {
             type: 'text',
@@ -164,12 +157,6 @@ Here is a script:
   strict: true,
   isolate: true,
   timeLimit: 60,
-  standard: 'also',
-  observe: false,
-  timeStamp: '240115T1200',
-  requester: 'you@yourdomain.com',
-  urlPrefix: '/file/reports',
-  urlSuffix: '.json',
   acts: [
     {
       type: 'placeholder',
@@ -199,17 +186,12 @@ A script has several properties that specify facts about the jobs to be created.
 - `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`: 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.
-- `observe`: If `true`, jobs will tell Testaro to allow granular observation of job progress. If `false`, jobs will tell Testaro not to permit granular observation, but only to send the report to the server 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 about 3 minutes.
-- `timeStamp`: This string specifies a UTC date and time when jobs created with the script are to be permitted to be assigned to agents. Thus, jobs can be created from a script for later performance. The value of `timeStamp` is a compact representation in the format `yymmddThhMM`. If the value is an empty string, Testilo will make the date and time equal to the time when jobs are created.
-- `requester`: the email address that any notices of job completion can be sent to, or an empty string if there is a `REQUESTER` environment variable and it is to be used.
-- `urlPrefix`: the start of a URL that the Testaro reports will be retrievable at.
-- `urlSuffix`: the end of that URL. The job ID will be inserted between the `urlPrefix` and the `urlSuffix`.
+- `timeLimit`: This specifies the maximum duration, in seconds, of a job. Testaro will abort jobs that are not completed within that time.
 - `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.
 
-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.
+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
 
@@ -225,13 +207,15 @@ A module can invoke `batch` in this way:
 
 ```javaScript
 const {batch} = require('testilo/batch');
-const batchObj = batch(listID, what, targets);
+const batchObj = batch(id, what, targets);
 ```
 
-This invocation references `listID`, `what`, and `targets` variables that the module must have already defined. The `listID` variable 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 3 items (ID, description, and URL) defining one target.
+This invocation references `id`, `what`, and `targets` variables that the module must have already defined. The `id` variable 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. The invoking module can further dispose of the batch as needed.
 
+The ID assigned to each target by the `batch()` function is a sequential (base-62 alphanumeric) string, rather than a mnemonic like the one (`'acme'`) in the above example.
+
 ##### By a user
 
 A user can invoke `batch` in this way:
@@ -299,6 +283,8 @@ To create a script without any issue restrictions, a user can execute the statem
 
 #### Options
 
+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.
+
 When the `script` module creates a script for you, it does not ask you for all of the options that the script may require. Instead, it chooses default options. After you invoke `script`, you can edit the script that it creates to revise options.
 
 ### Merge
@@ -317,16 +303,14 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
   timeLimit: 60,
   standard: 'also',
   observe: false,
+  sendReportTo: 'https://ourdomain.com/testman/api/report'
   timeStamp: '240115T1200',
   acts: [
     {
       type: 'launch',
-      which: 'chromium'
-    },
-    {
-      type: 'url',
-      which: 'https://acmeclothes.com/login.html',
-      what: 'Acme Clothes login page'
+      which: 'chromium',
+      what: 'Acme Clothes login page',
+      url: 'https://acmeclothes.com/login.html'
     },
     {
       type: 'text',
@@ -357,12 +341,9 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
     },
     {
       type: 'launch',
-      which: 'chromium'
-    },
-    {
-      type: 'url',
-      which: 'https://acmeclothes.com/login.html',
-      what: 'Acme Clothes login page'
+      which: 'chromium',
+      what: 'Acme Clothes login page',
+      url: 'https://acmeclothes.com/login.html'
     },
     {
       type: 'text',
@@ -399,19 +380,18 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
       id: 'acme',
       what: 'Acme Clothes'
     },
-    requester: 'you@yourdomain.tld',
-    url: '/file/reports/240115T1200-4Rw-acme.json'
+    requester: 'you@yourdomain.tld'
   },
-  creationTime: '2023-11-20T15:50:27'
+  creationTime: '241120T1550'
 }
 ```
 
 Testilo has substituted the `private` acts from the `acme` target of the batch for the placeholder when creating the job. Testilo also has:
 - inserted a copy of those same acts after the `axe` test act, because `axe` is a target-modifying tool.
 - let the script determine the browser type of the `launch` act.
-- added the creation time to the job.
 - given the job an ID that combines the time stamp with a differentiator and the batch ID.
 - inserted a `sources` property into the job, recording facts about the script, the batch, the target, the requester, and the report URL.
+- added a time stamp describing the creation time to the job.
 
 This is a valid Testaro job.
 
@@ -425,25 +405,18 @@ A module can invoke `merge` in this way:
 
 ```javaScript
 const {merge} = require('testilo/merge');
-const jobs = merge(
-  script, batch, requester, isolate, standard, isGranular, timeStamp, 'file/reports/', '.json'
-);
+const jobs = merge(script, batch, standard, observe, requester, timeStamp);
 ```
 
-The `merge` module uses these 9 arguments to create jobs from a script and a batch.
+The `merge` module uses these 4 arguments to create jobs from a script and a batch.
 
 The arguments are:
 - `script`: a script.
 - `batch`: a batch.
-- `requester`: an email address, or an empty string if there is a `REQUESTER` environment variable to be used.
-- `isolate`: `true` if test isolation is to be performed, or `false` if not.
-- `standard`: one of the standardization options (`'also'`, `'only'`, or `'no'`).
-- `isGranular`: `true` if Testaro is to allow granular observation of the job when performed under a network watch, or `false` if not.
-- `timeStamp`: a time stamp in the format `240115T1200`.
-- `urlPnrefix`: the start of an absolute or relative report URL.
-- `urlSuffix`: the end of a report URL.
-
-In this case, a job with ID `240115T1200-4Rw-acme` will produce a report that can be retrieved at the relative URL `/file/reports/240115T1200-4Rw-acme.json`.
+- `standard`: 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.
+- `observe`: whether to allow granular observation. If `true`, jobs will tell Testaro to permit granular observation of job progress. If `false`, jobs will tell Testaro not to permit granular observation, but only to send the report to the server 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 about 3 minutes.
+- `requester`: an email address.
+- `timeStamp`: the earliest UTC date and time when the jobs may be assigned (format `240415T1230`), or an empty string if now.
 
 The `merge()` function of the `merge` module generates jobs and returns them in an array. The invoking module can further dispose of the jobs as needed.
 
@@ -453,21 +426,20 @@ A user can invoke `merge` in this way:
 
 - Create a script and save it as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
 - Create a batch and save it as a JSON file in the `batches` subdirectory of the `SPECDIR` directory.
-- In the Testilo project directory, execute the statement `node call merge scriptName batchName requester isolate standard observe todoDir urlPrefix urlSuffix`.
+- In the Testilo project directory, execute the statement:
+
+```javascript
+node call merge scriptID batchID standard observe requester timeStamp todoDir
+```
 
 In this statement, replace:
-- `scriptName` with the base name of the script file.
-- `batchName` with the base name of the batch file.
-- `requester` with an email address, or with an empty string if the environment variable `REQUESTER` exists and you want to use it.
-- `isolate` with `true` if you want test isolation or `false` if not.
-- `standard` with `'also'`, `'only'`, or `'no'` to specify the treatment of standard-format results.
-- `observe` with `true` if granular observation is to be permitted, or `false` if not.
-- `todoDir` with `true` if the job is to be saved in the `todo` subdirectory, or `false` if it is to be saved in the `pending` subdirectory, of the `JOBDIR` directory.
-- `urlPrefix` with the pre-ID part of the report URL.
-- `urlSuffix` with the post-ID part of the report URL.
+- `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`, and `timeStamp` as described above.
+- `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.
-The `merge` module will create an array of jobs, with or without test isolation.
+The `merge` module will create an array of jobs.
 The `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `JOBDIR` directory.
 
 #### Validation
@@ -733,3 +705,11 @@ The third argument to `call` (`23pl` in this example) is optional. If it is omit
 ### Validation
 
 To test the `compare` module, in the project directory you can execute the statement `node validation/compare/validate`. If `compare` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
+
+## Origin
+
+Work on the functionalities of Testaro and Testilo began in 2017. It was named [Autotest](https://github.com/jrpool/autotest) in early 2021 and then partitioned into the more single-purpose packages Testaro and Testilo in January 2022.
+
+## Etymology
+
+“Testilo” means “testing tool” in Esperanto.

package/batch.js

@@ -3,7 +3,11 @@
   Converts a target list to a batch.
 */
 
-// ########## FUNCTIONS
+// IMPORTS
+
+const {alphaNumOf} = require('./procs/util');
+
+// FUNCTIONS
 
 // Converts a target list to a batch and returns the batch.
 exports.batch = (id, what, targetList) => {
@@ -17,9 +21,9 @@ exports.batch = (id, what, targetList) => {
     && targetList.length
     && targetList.every(
       target => Array.isArray(target)
+      && target.length === 2
       && target.every(item => typeof item === 'string')
     )
-    && targetList.some(target => target.length === 3)
   ) {
     // Initialize the batch.
     const batch = {
@@ -27,25 +31,23 @@ exports.batch = (id, what, targetList) => {
       what,
       targets: []
     };
-    // For each valid target:
-    targetList.forEach(target => {
-      if (target.length === 3 && target.every(item => item.length)) {
-        // Add it to the batch.
-        batch.targets.push({
-          id: target[0],
-          which: target[2],
-          what: target[1],
-          acts: {
-            main: [
-              {
-                type: 'launch',
-                url: target[2],
-                what: target[1]
-              }
-            ]
-          }
-        });
-      }
+    // For each target:
+    targetList.forEach((target, index) => {
+      // Add it to the batch.
+      batch.targets.push({
+        id: alphaNumOf(index),
+        what: target[0],
+        which: target[1],
+        acts: {
+          main: [
+            {
+              type: 'launch',
+              what: target[0],
+              url: target[1]
+            }
+          ]
+        }
+      });
     });
     // Return the batch.
     return batch;
@@ -53,6 +55,7 @@ exports.batch = (id, what, targetList) => {
   // Otherwise, i.e. if the arguments are invalid:
   else {
     // Return this.
+    console.log('ERROR: Batch information missing or invalid');
     return null;
   }
 };

package/call.js

@@ -43,16 +43,21 @@ const fnArgs = process.argv.slice(3);
 // ########## FUNCTIONS
 
 // Converts a target list to a batch.
-const callBatch = async (listID, what) => {
+const callBatch = async (id, what) => {
   // Get the target list.
-  const listString = await fs.readFile(`${specDir}/targetLists/${listID}.tsv`, 'utf8');
-  const list = listString.split('\n').map(target => target.split('\t'));
+  const listString = await fs.readFile(`${specDir}/targetLists/${id}.tsv`, 'utf8');
+  const list = listString
+  .split('\n')
+  .filter(target => target.length)
+  .map(target => target.split('\t'));
   // Convert it to a batch.
-  const batchObj = batch(listID, what, list);
+  const batchObj = batch(id, what, list);
   // Save the batch.
-  const batchJSON = JSON.stringify(batchObj, null, 2);
-  await fs.writeFile(`${specDir}/batches/${listID}.json`, `${batchJSON}\n`);
-  console.log(`Target list ${listID} converted to a batch and saved in ${specDir}/batches`);
+  if (batchObj) {
+    const batchJSON = JSON.stringify(batchObj, null, 2);
+    await fs.writeFile(`${specDir}/batches/${id}.json`, `${batchJSON}\n`);
+    console.log(`Target list ${id} converted to a batch and saved in ${specDir}/batches`);
+  }
 };
 // Fulfills a script-creation request.
 const callScript = async (scriptID, classificationID = null, ... issueIDs) => {
@@ -71,11 +76,11 @@ const callScript = async (scriptID, classificationID = null, ... issueIDs) => {
 const callMerge = async (
   scriptID,
   batchID,
-  requester,
-  withIsolation,
   standard,
-  isGranular,
-  todo
+  observe,
+  requester,
+  timeStamp,
+  todoDir
 ) => {
   // Get the script and the batch.
   const scriptJSON = await fs.readFile(`${specDir}/scripts/${scriptID}.json`, 'utf8');
@@ -83,19 +88,15 @@ 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, requester, withIsolation, standard, isGranular, null, urlPrefix, urlSuffix
-  );
+  const jobs = merge(script, batch, standard, observe === 'true', requester, timeStamp);
   // Save the jobs.
-  const destination = todo === 'true' ? 'todo' : 'pending';
+  const subdir = `${jobDir}/${todoDir === 'true' ? 'todo' : 'pending'}`;
   for (const job of jobs) {
     const jobJSON = JSON.stringify(job, null, 2);
-    await fs.writeFile(`${jobDir}/${destination}/${job.id}.json`, `${jobJSON}\n`);
+    await fs.writeFile(`${subdir}/${job.id}.json`, `${jobJSON}\n`);
   }
-  const {timeStamp} = jobs[0];
-  console.log(
-    `Script ${scriptID} and batch ${batchID} merged as ${timeStamp}-… in ${jobDir}/${destination}`
-  );
+  const truncatedID = `${jobs[0].timeStamp}-${jobs[0].mergeID}-…`;
+  console.log(`Script ${scriptID} and batch ${batchID} merged as ${truncatedID} in ${subdir}`);
 };
 // Gets selected reports.
 const getReports = async (type, selector = '') => {
@@ -222,7 +223,7 @@ else if (fn === 'script' && fnArgs.length) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'merge' && fnArgs.length === 9) {
+else if (fn === 'merge' && fnArgs.length === 7) {
   callMerge(... fnArgs)
   .then(() => {
     console.log('Execution completed');

package/merge.js

@@ -1,83 +1,34 @@
 /*
   merge.js
   Merges a script and a batch and returns jobs.
-  Arguments:
-    0. script
-    1. batch
-    2. requester
-    3. whether to provide test isolation
-    4. value of the standard property
-    5. whether reporting is to be granular
-    6. date and time as a compact timestamp for job execution, if not now
 */
 
 // ########## IMPORTS
 
 // Module to keep secrets.
 require('dotenv').config();
+// Module to perform common actions.
+const {alphaNumOf, dateOf, getRandomString, getNowStamp} = require('./procs/util');
 
 // ########## CONSTANTS
 
-// Standard requester.
-const stdRequester = process.env.REQUESTER || 'nobody@nodomain.tld';
-// Length of the random part of a job ID, as a string.
-const randomIDLength = process.env.RANDOM_ID_LENGTH || '3';
 // Tools that alter the page.
 const contaminantNames = new Set([
   'alfa',
   'aslint',
   'axe',
+  'ed11y',
   'htmlcs',
   'testaro'
 ]);
-const randomIDChars = (() => {
-  const digits = Array(10).fill('').map((digit, index) => index.toString());
-  const uppers = Array(26).fill('').map((letter, index) => String.fromCodePoint(65 + index));
-  const lowers = Array(26).fill('').map((letter, index) => String.fromCodePoint(97 + index));
-  return digits.concat(uppers, lowers);
-})();
-
+// Length of the random merger ID.
+const mergeIDLength = 2;
 
 // ########## FUNCTIONS
 
-// Inserts a character periodically in a string.
-const punctuate = (string, insertion, chunkSize) => {
-  const segments = [];
-  let startIndex = 0;
-  while (startIndex < string.length) {
-    segments.push(string.slice(startIndex, startIndex + chunkSize));
-    startIndex += chunkSize;
-  }
-  return segments.join(insertion);
-};
-// Converts a compact timestamp to a date.
-const dateOf = timeStamp => {
-  if (/^\d{6}T\d{4}$/.test(timeStamp)) {
-    const dateString = punctuate(timeStamp.slice(0, 6), '-', 2);
-    const timeString = punctuate(timeStamp.slice(7, 11), ':', 2);
-    return new Date(`20${dateString}T${timeString}Z`);
-  } else {
-    return null;
-  }
-};
-// Converts a date and time to a compact timestamp.
-const stampTime = date => date.toISOString().replace(/[-:]/g, '').slice(2, 13);
-// Generates a random string.
-const getRandomID = length => {
-  const chars = [];
-  for (let i = 0; i < length; i++) {
-    chars.push(randomIDChars[Math.floor(62 * Math.random())]);
-  }
-  return chars.join('');
-};
 // Merges a script and a batch and returns jobs.
-exports.merge = (
-  script, batch, requester, isolate, standard, observe, timeStamp, urlPrefix, urlSuffix
-) => {
-  if (isolate === 'false') {
-    isolate = false;
-  }
-  // If a timestamp was specified:
+exports.merge = (script, batch, standard, observe, requester, timeStamp) => {
+  // If a time stamp was specified:
   if (timeStamp) {
     // If it is invalid:
     if (! dateOf(timeStamp)) {
@@ -86,77 +37,79 @@ exports.merge = (
       return [];
     }
   }
-  // Otherwise, i.e. if no timestamp was specified:
+  // Otherwise, i.e. if no time stamp was specified:
   else {
     // Create one for the job.
-    timeStamp = stampTime(new Date());
+    timeStamp = getNowStamp();
   }
-  // If the requester is blank or unspecified, make it the standard requester.
-  requester ||= stdRequester;
-  // Create a creation-time description.
-  const creationTime = (new Date()).toISOString().slice(0, 16);
-  // Initialize a target-independent job.
+  // Initialize a job as a copy of the script.
   const protoJob = JSON.parse(JSON.stringify(script));
-  // Make the timestamp and a random string the start of the job ID.
-  protoJob.id = `${timeStamp}-${getRandomID(Number.parseInt(randomIDLength, 10))}-`;
-  // Add a sources property to the job.
+  // Add an initialized sources property to it.
   protoJob.sources = {
     script: script.id,
     batch: batch.id,
     target: {
       id: '',
-      which: '',
-      what: ''
+      what: '',
+      which: ''
     },
-    requester,
-    sendReportTo: process.env.REPORT_URL || '',
-    url: ''
+    requester
   };
   // Add properties to the job.
-  protoJob.creationTime = creationTime;
+  protoJob.standard = standard;
+  protoJob.observe = observe;
   protoJob.timeStamp = timeStamp;
-  protoJob.standard = standard || 'only';
-  protoJob.observe = observe || false;
+  protoJob.creationTimeStamp = getNowStamp();
   // If isolation was requested:
-  if (isolate) {
-    // Configure the job for it.
+  if (script.isolate) {
+    // For each act:
     let {acts} = protoJob;
     let lastPlaceholder = {};
     for (const actIndexString in acts) {
+      // If it is a placeholder:
       const actIndex = Number.parseInt(actIndexString);
       const act = acts[actIndex];
-      const nextAct = acts[actIndex + 1];
       if (act.type === 'placeholder') {
+        // Identify it as the current one.
         lastPlaceholder = act;
       }
+      // Otherwise, if it is a non-final target-modifying test act:
       else if (
         act.type === 'test'
         && contaminantNames.has(act.which)
         && actIndex < acts.length - 1
-        && (nextAct.type === 'test')
       ) {
+        // Change it to an array of itself and the current placeholder.
         acts[actIndex] = JSON.parse(JSON.stringify([act, lastPlaceholder]));
       }
     };
+    // Flatten the acts.
     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;
-  for (const target of targets) {
+  targets.forEach((target, index) => {
     // If the target has the required identifiers:
-    const {id, which, what} = target;
-    if (id && which && what) {
+    const {id, what, which} = target;
+    if (id && what && which) {
       // Initialize a job.
       const job = JSON.parse(JSON.stringify(protoJob));
-      // Append the target ID to the job ID.
-      job.id += target.id;
+      // Make the job ID unique.
+      const targetID = alphaNumOf(index);
+      job.id = `${timeStamp}-${mergeID}-${targetID}`;
+      // Add properties to the job.
+      job.mergeID = mergeID;
+      job.sendReportTo = process.env.SEND_REPORT_TO || '';
       // Add data to the sources property of the job.
-      job.sources.target.id = target.id;
-      job.sources.target.which = target.which;
+      job.sources.target.id = targetID;
       job.sources.target.what = target.what;
-      job.sources.url = `${urlPrefix}${job.id}${urlSuffix}`;
+      job.sources.target.which = target.which;
       // Replace each placeholder object in the job with the named replacer array of the target.
       let {acts} = job;
       for (const actIndex in acts) {
@@ -184,13 +137,14 @@ exports.merge = (
           }
         }
       }
+      // Flatten the acts.
       job.acts = acts.flat();
       // Append the job to the array of jobs.
       jobs.push(job);
     }
     else {
-      console.log('ERROR: Target in batch missing id, which, or what property');
+      console.log('ERROR: Target in batch missing id, what, or which property');
     }
-  };
+  });
   return jobs;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testilo",
-  "version": "23.0.0",
+  "version": "24.0.0",
   "description": "Prepares and processes Testaro reports",
   "main": "aim.js",
   "scripts": {

package/procs/test.js

@@ -0,0 +1,20 @@
+// Array of 62 alphanumeric characters.
+const alphaNumChars = (() => {
+  const digits = Array(10).fill('').map((digit, index) => index.toString());
+  const uppers = Array(26).fill('').map((letter, index) => String.fromCodePoint(65 + index));
+  const lowers = Array(26).fill('').map((letter, index) => String.fromCodePoint(97 + index));
+  return digits.concat(uppers, lowers);
+})();
+
+// Returns an alphanumeric representation of an integer.
+const alphaNumOf = num => {
+  let resultDigits = [];
+  while (num) {
+    const remainder = num % 62;
+    resultDigits.unshift(alphaNumChars[remainder]);
+    num = Math.floor(num / 62);
+  }
+  return resultDigits.join('');
+};
+
+console.log(alphaNumOf(process.argv[2]));

package/procs/util.js

@@ -0,0 +1,63 @@
+/*
+  util.js
+  Utility functions.
+*/
+
+// CONSTANTS
+
+// Array of 62 alphanumeric characters.
+const alphaNumChars = (() => {
+  const digits = Array(10).fill('').map((digit, index) => index.toString());
+  const uppers = Array(26).fill('').map((letter, index) => String.fromCodePoint(65 + index));
+  const lowers = Array(26).fill('').map((letter, index) => String.fromCodePoint(97 + index));
+  return digits.concat(uppers, lowers);
+})();
+
+// FUNCTIONS
+
+// Returns a string representing a date and time.
+const getTimeString = date => date.toISOString().slice(0, 19);
+// Returns a string representing the date and time.
+exports.getNowString = () => getTimeString(new Date());
+// Returns a time stamp representing a date and time.
+const getTimeStamp = date => getTimeString(date).replace(/[-:]/g, '').slice(2, 13);
+// Returns a time stamp representing the date and time.
+exports.getNowStamp = () => getTimeStamp(new Date());
+// Inserts a character periodically in a string.
+const punctuate = (string, insertion, chunkSize) => {
+  const segments = [];
+  let startIndex = 0;
+  while (startIndex < string.length) {
+    segments.push(string.slice(startIndex, startIndex + chunkSize));
+    startIndex += chunkSize;
+  }
+  return segments.join(insertion);
+};
+// Converts a compact timestamp to a date.
+exports.dateOf = timeStamp => {
+  if (/^\d{6}T\d{4}$/.test(timeStamp)) {
+    const dateString = punctuate(timeStamp.slice(0, 6), '-', 2);
+    const timeString = punctuate(timeStamp.slice(7, 11), ':', 2);
+    return new Date(`20${dateString}T${timeString}Z`);
+  } else {
+    return null;
+  }
+};
+// Returns a base-62 alphanumeric representation of an integer.
+exports.alphaNumOf = num => {
+  let resultDigits = [];
+  while (num || ! resultDigits.length) {
+    const remainder = num % 62;
+    resultDigits.unshift(alphaNumChars[remainder]);
+    num = Math.floor(num / 62);
+  }
+  return resultDigits.join('');
+};
+// Returns a random string.
+exports.getRandomString = length => {
+  const chars = [];
+  for (let i = 0; i < length; i++) {
+    chars.push(alphaNumChars[Math.floor(62 * Math.random())]);
+  }
+  return chars.join('');
+};

package/script.js

@@ -71,9 +71,6 @@ exports.script = (id, issues = null, ... issueIDs) => {
       strict: true,
       isolate: true,
       timeLimit: 30 + (10 * issueIDs.length || 30 * toolIDs.length),
-      standard: 'only',
-      observe: true,
-      timeStamp: '',
       acts: [
         {
           "type": "placeholder",
@@ -99,7 +96,7 @@ exports.script = (id, issues = null, ... issueIDs) => {
           toolAct.rules.unshift('y');
         }
       }
-      // Add any needed option specifications to the act.
+      // Add any needed option defaults to the act.
       if (toolID === 'axe') {
         toolAct.detailLevel = 2;
       }