testilo 22.1.0 → 23.1.0

package/README.md

@@ -5,7 +5,7 @@ Utilities for Testaro
 
 The Testilo package contains utilities that facilitate the use of the [Testaro](https://www.npmjs.com/package/testaro) package.
 
-Testaro performs digital accessibility tests on web artifacts and creates reports in JSON format. The utilities in Testilo fall into two categories:
+Testaro performs jobs and creates reports in JSON format. The utilities in Testilo fall into two categories:
 - Job preparation
 - Report enhancement
 
@@ -21,24 +21,34 @@ When Testilo is a dependency of another application, the `.env` file is not impo
 
 Testilo is written in Node.js. Commands are given to Testilo in a command-line (terminal) interface or programmatically.
 
-Shared routines are _procs_ and are located in the `procs` directory.
+Shared routines, called _procs_, are located in the `procs` directory.
 
 Testilo can be installed wherever Node.js (version 14 or later) is installed. This can be a server or the same workstation on which Testaro is installed.
 
-The reason for Testilo being an independent package, rather than part of Testaro, is that Testilo can be installed on any host, while Testaro can run successfully only on a Windows or Macintosh workstation (and perhaps on some workstations with Ubuntu operating systems). Testaro runs tests similar to those that a human accessibility tester would run, using whatever browsers, input devices, system settings, simulated and attached devices, and assistive technologies tests may require. Thus, Testaro is limited to functionalities that require workstation attributes. For maximum flexibility in the management of Testaro jobs, all other functionalities are located outside of Testaro. You could have software such as Testilo running on a server, communicating with multiple workstations running Testaro. The workstations could receive job orders from the server and return job results to the server for further processing.
+The reason for Testilo being an independent package, rather than part of Testaro, is that Testilo can be installed on any host, while Testaro can run successfully only on a Windows, Macintosh, Ubuntu, or Debian workstation. Testaro runs tests similar to those that a human accessibility tester would run, using whatever browsers, input devices, system settings, simulated and attached devices, and assistive technologies tests may require. Thus, Testaro is limited to functionalities that require workstation attributes. For maximum flexibility in the management of Testaro jobs, all other functionalities are located outside of Testaro. You could have software such as Testilo running on a server, communicating with multiple workstations running Testaro. The workstations could receive jobs from the server and return job reports to the server for further processing.
 
 ## Configuration
 
 Environment variables for Testilo can be specified in a `.env` file. An example:
 
 ```bash
-FUNCTIONDIR=../testdir/procs
+FUNCTIONDIR=./procs
 JOBDIR=../testdir/jobs
 REPORTDIR=../testdir/reports
 REQUESTER=a11ymgr@a11yorg.com
 SPECDIR=../testdir/specs
 ```
 
+The `FUNCTIONDIR` environment variable typically references the `procs` directory, but it could reference a different directory in the filesystem where Testilo resides, if you wanted to customize the procs that Testilo uses.
+
+`JOBDIR` references a directory in the filesystem where jobs created by the `merge` proc are to be saved.
+
+`REPORTDIR` references a directory in the filesystem where reports are saved.
+
+`REQUESTER` is an email address that will be used as a job property if no other email address is specified for the `sources.requester` property of the job.
+
+`SPECDIR` references a directory in the filesystem where tanrget lists, batches, and scripts can be found. Those are raw materials from which Testaro creates jobs.
+
 ## Job preparation
 
 ### Introduction
@@ -49,20 +59,30 @@ You can create a job for Testaro directly, without using Testilo.
 
 Testilo can, however, make job preparation more efficient in these scenarios:
 - You want to perform a battery of tests on multiple targets.
-- You want to test targets for particular issues, using whichever tools happen to have tests for those issues.
+- You want to test targets only for particular issues, using whichever tools happen to have tests for those issues.
 
 ### Target lists
 
-The simplest version of a list of targets is a _target list_. It is an array of arrays defining 1 or more targets. It is stored as a tab-delimited text file, with one line per target. Each line contains 3 items, with tabs between them:
-- An ID for the target
-- A description of the target
-- The URL of the target
+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 2 items:
+- A description
+- A URL
 
-For example, a stored target list (with “→” representing the Tab character) might be:
+For example, a target list might be:
+
+```javaScript
+[
+  ['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
@@ -76,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',
@@ -128,9 +142,11 @@ 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.
 
+A batch is a JavaScript object. It can be converted to JSON and stored in a file.
+
 ### 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 one batch can generate an unlimited number of jobs.
+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.
 
 Here is a script:
 
@@ -143,7 +159,6 @@ Here is a script:
   timeLimit: 60,
   standard: 'also',
   observe: false,
-  timeStamp: '240115T1200',
   acts: [
     {
       type: 'placeholder',
@@ -169,18 +184,18 @@ Here is a script:
 ```
 
 A script has several properties that specify facts about the jobs to be created. They include:
-- `id`: an ID that uniquely distinguishes the script from other scripts.
+- `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.
 - `what`: a description of the script.
-- `strict`: You decide whether Testaro is to throw an error on an attempt to navigate to a URL if the server redirects the request to a URL differing substantially from the specified URL. All differences are considered substantial unless the URLs differ only in the presence and absence of a trailing slash.
-- `isolate`: You decide whether to isolate test acts, as needed, from effects of previous test acts. If `true`, the `merge` module will add a copy of the latest placeholder after each target-modifying test act before the immediately following test act.
-- `standard`: You choose how the reports of test acts should be standardized. The alternatives are `'no'` (do not standardize), `'also'` (standardize and report both the original and the standardized results), and `'only'` (standardize and report only the standardized results).
-- `observe`: You decide how granularly Testaro will allow a server to observe job progress. If `true`, Testaro sends a message to the server to announce each test act (identifying the tool), and the `testaro` tool sends a message to the server to announce each rule when its test is performed. The server can further update the requesting client on the basis of these messages. It is generally user-friendly to make `observe` `true` if the user application makes the user wait while the job is assigned and performed. If the application allows the user to leave and sends the user a message when the job has been completed, `observe` can be set to `false`.
-- `timeStamp`: You can specify the date and time that the job is to wait for before it is performed. This specification is a string with the format `yymmddThhMM`.
+- `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.
+- `timeLimit`: This specifies the maximum duration, in seconds, of a job. Testaro will abort jobs that are not completed within that time.
+- `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.
 - `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
 
@@ -196,33 +211,35 @@ 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:
 
-- 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 `process.env.SPECDIR` directory. Name the file `x.tsv`, where `x` is the list ID.
-- In the Testilo project directory, execute the statement `node call batch i w`.
+- 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.tsv`, where `x` is the list ID.
+- In the Testilo project directory, execute the statement `node call batch id what`.
 
-In this statement, replace `i` with the list ID and `w` with a description of the batch.
+In this statement, replace `id` with the list ID and `what` with a string describing the batch.
 
 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 in the `batches` subdirectory of the `process.env.SPECDIR` directory.
+The `call` module will save the batch as a JSON file in the `batches` subdirectory of the `SPECDIR` directory.
 
 ### Issues to script
 
-Testilo classifies tool rules into _issues_. The built-in classifications are located in the `procs/score` directory, in files whose names begin with `tic` (for “Testilo issue classification”). You can create additional `tic` files with custom classifications.
+Testilo contains a classification of tool rules into _issues_. It is located in the `procs/score` directory and has a file name starting with `tic` (Testilo issue classification). You can create custom classifications and save them in a `score` subdirectory of the `FUNCTIONDIR` directory.
 
 For example, one of the issues in the `tic40.js` file is `mainNot1`. Four rules are classified as belonging to that issue: rule `main_element_only_one` of `aslint` and 3 more rules defined by 3 other tools.
 
-If you want Testaro to test targets for only particular issues, you can name those issues and use the Testilo `script` module to create a script for that purpose. The only tools called by the script will be tools that define rules that are classified as belonging to one or more issues named.
+If you want Testaro to test targets for only particular issues, you can use the `script` module to create a script. Jobs created from that script will make Testaro test for only the issues you specify to the `script` module.
 
 If you want Testaro to test targets for **all** the rules of all the available tools, you can use the `script` module to create a script that does not impose any issue restrictions.
 
@@ -240,9 +257,9 @@ const scriptObj = script(scriptID, issues, issueID0, issueID1, …);
 ```
 
 This invocation references `scriptID`, `issues`, and `issueID` variables.
-- The `scriptID` variable is an arbitrary alphanumeric string.
+- The `scriptID` variable specifies the ID that the script will have.
 - The `issues` variable (if present) is an object that classifies issues, such as the `issues` object in a `tic` file.
-- The `issueID` variables (if any) are strings, such as `'regionNoText'`, that name properties of the `issues` object.
+- The `issueID` variables (if any) are strings, such as `'regionNoText'`, that name issues, i.e. properties of the `issues` object, that you want jobs from the script to test for.
 
 The `script()` function of the `script` module generates a script and returns it as an object. The invoking module can further modify and use the script as needed.
 
@@ -255,50 +272,49 @@ const scriptObj = script(scriptID);
 
 ##### By a user
 
-A user can invoke `script` in this way: In the Testilo project directory, execute the statement `node call script s c i0 i1 i2 i3 …`.
+A user can invoke `script` in this way: In the Testilo project directory, execute the statement `node call script id ticnn issuea issueb …`.
 
 In this statement:
-- Replace `s` with an arbitrary ID for the script, such as `headings`.
-- Replace `c` with the base name, such as `tic99`, of an issue classification file in the `score` subdirectory of the `process.env.FUNCTIONDIR` directory.
-- Replace the remaining arguments (`i0` etc.) with issue IDs from that classification file.
+- Replace `id` with an ID for the script, such as `headings`.
+- Replace `ticnn` with the base, such as `tic99`, of the name of an issue classification file in the `score` subdirectory of the `FUNCTIONDIR` directory.
+- Replace the remaining arguments (`issuea` etc.) with issue names from that classification file.
 
 The `call` module will retrieve the named classification.
 The `script` module will create a script.
-The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `process.env.SPECDIR` directory.
+The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
 
-To create a script without any issue restrictions, a user can execute the statement `node call script s`.
+To create a script without any issue restrictions, a user can execute the statement `node call script id`.
 
 #### Options
 
-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 options. After you invoke `script`, you can edit the script that it creates to revise 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
 
 Testilo merges batches with scripts, producing jobs, by means of the `merge` module.
 
-The `merge` module needs to be given a batch and a script.
-
 #### Output
 
-##### Without isolation
-
-Suppose you ask for a merger of the above batch and script, **without** the isolation option. Then the first job produced by `merge` will look like this:
+Suppose you ask for a merger of the above batch and script. Then the first job produced by `merge` will look like this:
 
 ```javaScript
 {
-  id: '231120T1550-ts99-acme',
-  what: 'Axe on account page',
+  id: '240115T1200-4Rw-acme',
+  what: 'aside mislocation',
   strict: true,
   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',
@@ -323,15 +339,42 @@ Suppose you ask for a merger of the above batch and script, **without** the isol
     {
       type: 'test',
       which: 'axe',
-      detailLevel: 1,
-      rules: [],
-      what: 'Axe core, all rules'
+      detailLevel: 2,
+      rules: ['landmark-complementary-is-top-level'],
+      what: 'Axe'
+    },
+    {
+      type: 'launch',
+      which: 'chromium',
+      what: 'Acme Clothes login page',
+      url: 'https://acmeclothes.com/login.html'
+    },
+    {
+      type: 'text',
+      which: 'User Name',
+      what: 'tester34'
+    },
+    {
+      type: 'text',
+      which: 'Password',
+      what: '34SecretTester'
+    },
+    {
+      type: 'button',
+      which: 'Submit',
+      what: 'submit the login form'
+    },
+    {
+      type: 'wait',
+      which: 'title',
+      what: 'account'
     },
     {
       type: 'test',
       which: 'qualWeb',
       withNewContent: false,
-      what: 'QualWeb, all rules'
+      rules: ['QW-BP25', 'QW-BP26']
+      what: 'QualWeb'
     }
   ],
   sources: {
@@ -343,32 +386,19 @@ Suppose you ask for a merger of the above batch and script, **without** the isol
     },
     requester: 'you@yourdomain.tld'
   },
-  creationTime: '2023-11-20T15:50:27',
-  timeStamp: '231120T155314'
+  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.
-- added a unique timestamp to the job (a more compact representation of the creation time).
-- given the job an ID that combines the timestamp with the script ID and the batch ID.
-- inserted a `sources` property into the job, recording facts about the script, the batch, the target, and the email address given by the user who requested the merger.
+- 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.
 
-##### With isolation
-
-If, however, you requested a merger **with** isolation, then Testilo would take cognizance of the fact that an `axe` test act is a target-modifying act. Testilo would therefore act as if another instance of the placeholder had been located in the script after the `axe` test act. So, copies of the same 6 acts that precede the `axe` test act would be inserted **after** the `axe` test act, too.
-
-Of the 9 tools providing tests for Testaro, 6 are target-modifying:
-- `alfa`
-- `aslint`
-- `axe`
-- `htmlcs`
-- `ibm`
-- `testaro`
-
 #### Invocation
 
 There are two ways to use the `merge` module.
@@ -379,10 +409,16 @@ A module can invoke `merge` in this way:
 
 ```javaScript
 const {merge} = require('testilo/merge');
-const jobs = merge(script, batch, requester, true, 'only', false, '240115T1200', 'jobs/', '.json');
+const jobs = merge(script, batch, requester, timeStamp);
 ```
 
-This invocation references `script`, `batch`, and `requester` variables that the module must have already defined. The `script` and `batch` variables are a script object and a batch object, respectively. The `requester` variable is an email address. The fourth argument is a boolean, specifying whether to perform test isolation. The fifth argument is a string that specifies the Testaro standardization option ('also', 'only', or 'no'). The sixth argument is a boolean, specifying whether Testaro will allow granular network observation of the job. The seventh and eights arguments are strings that contain the parts, before and after the job ID, respectively, of the absolute or relative URL for retrieving the job report. In this case, a job with ID `20240420T1426-R7T-archive` will produce a report that can be retrieved at the relative URL `jobs/20240420T1426-R7T-archive.json`.
+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.
+- `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.
 
@@ -390,75 +426,23 @@ The `merge()` function of the `merge` module generates jobs and returns them in
 
 A user can invoke `merge` in this way:
 
-- Create a script and save it as a JSON file in the `scripts` subdirectory of the `process.env.SPECDIR` directory.
-- Create a batch and save it as a JSON file in the `batches` subdirectory of the `process.env.SPECDIR` directory.
-- In the Testilo project directory, execute this statement:
-    - `node call merge scriptName batchName email isolate standard granular todoDir pre post`
-
-In these statements, replace:
-- `scriptName` with the base name of the script file
-- `batchName` with the base name of the batch file
-- `email` with an email address, or with an empty string if the environment variable `process.env.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.
-- `granular` 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 `process.env.JOBDIR` directory.
-- `pre` with the pre-ID part of the report URL.
-- `post` with the post-ID part of the report URL.
-
-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 `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `process.env.JOBDIR` directory.
-
-#### Validation
-
-To test the `merge` module, in the project directory you can execute the statement `node validation/merge/validate`. If `merge` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
-
-### Series
-
-If you want to monitor a web resource by performing identical jobs repeatedly and comparing the results, you can use the `series` module to create a series of identical jobs.
-
-The jobs in a series differ from one another only in the timestamp segments of their `id` properties. For example, if the first job had the `id` value `240528T1316-mon-mozilla` and the events in the series occurred at intervals of 12 hours, then the second job would have the `id` value `240529T0116-mon-mozilla`.
-
-The `series` module adds a `sources.series` property to each job in the series. The value of that property is the `id` value of the first job in the series.
-
-To support monitoring, a server that receives job requests from testing agents can perform a time check on the first job in the queue. If the time specified by the `id` of the first job is in the future, the server can reply that there is no job to do.
-
-#### Invocation
-
-There are two ways to use the `series` module.
-
-##### By a module
-
-A module can invoke `series` in this way:
-
-```javaScript
-const {series} = require('testilo/series');
-const jobs = series(job, count, interval);
-```
-
-This invocation references a `job` variable, whose value is a job object. The `count` variable is an integer, 2 or greater, specifying how many events the series consists of. The `interval` variable is an integer, 1 or greater, specifying how many minutes are to elapse after each event before the next event. The `series()` function of the `series` module generates an array of job objects and returns the array. The invoking module can further dispose of the jobs as needed.
-
-##### By a user
-
-A user can invoke `series` in this way:
-
-- Create a job and save it as a JSON file in the `todo` subdirectory of the `process.env.JOBDIR` directory.
-- In the Testilo project directory, execute this statement:
-    - `node call series j c i`
+- 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 scriptID batchID requester timeStamp todoDir`.
 
 In this statement, replace:
-- `j` with a string that the filename of the starting job begins with
-- `c` with a count
-- `i` with an interval in minutes
+- `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.
+- `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 first job that matches `j` from the `pending` subdirectory of the `process.env.JOBDIR` directory.
-The `series` module will create an array of jobs.
-The `call` module will save the jobs as JSON files in the `todo` subdirectory of the `process.env.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.
+The `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `JOBDIR` directory.
 
 #### Validation
 
-To test the `series` module, in the project directory you can execute the statement `node validation/series/validate`. If `series` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
+To test the `merge` module, in the project directory you can execute the statement `node validation/merge/validate`. If `merge` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
 
 ## Report scoring
 
@@ -719,3 +703,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: information missing or invalid');
     return null;
   }
 };

package/call.js

@@ -24,8 +24,6 @@ const {batch} = require('./batch');
 const {script} = require('./script');
 // Function to process a merger.
 const {merge} = require('./merge');
-// Function to generate a job series.
-const {series} = require('./series');
 // Function to score reports.
 const {score} = require('./score');
 // Function to digest reports.
@@ -45,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) => {
@@ -74,10 +77,8 @@ const callMerge = async (
   scriptID,
   batchID,
   requester,
-  withIsolation,
-  standard,
-  isGranular,
-  todo
+  timeStamp,
+  todoDir
 ) => {
   // Get the script and the batch.
   const scriptJSON = await fs.readFile(`${specDir}/scripts/${scriptID}.json`, 'utf8');
@@ -85,42 +86,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, 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`);
-  }
-  const {timeStamp} = jobs[0];
-  console.log(
-    `Script ${scriptID} and batch ${batchID} merged as ${timeStamp}-… in ${jobDir}/${destination}`
-  );
-};
-// Fulfills a series request.
-const callSeries = async (idStart, count, interval) => {
-  // Get the initial job.
-  const jobNames = await fs.readdir(`${jobDir}/pending`);
-  const seriesJobName = jobNames.find(jobName => jobName.startsWith(idStart));
-  // If it exists:
-  if (seriesJobName) {
-    // Generate a job series.
-    const jobJSON = await fs.readFile(`${jobDir}/todo/${seriesJobName}`, 'utf8');
-    const job = JSON.parse(jobJSON);
-    const jobSeries = series(job, Number.parseInt(count), Number.parseInt(interval));
-    // Save the jobs.
-    for (const item of jobSeries) {
-      await fs.writeFile(`${jobDir}/todo/${item.id}.json`, `${JSON.stringify(item, null, 2)}\n`);
-    }
-    console.log(`Series of ${jobSeries.length} jobs generated and saved in ${jobDir}/todo`);
-  }
-  // Otherwise, i.e. if it does not exist:
-  else {
-    // Report this.
-    console.log('ERROR: No matching to-do job found');
+    await fs.writeFile(`${subdir}/${job.id}.json`, `${jobJSON}\n`);
   }
+  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 = '') => {
@@ -247,18 +221,12 @@ else if (fn === 'script' && fnArgs.length) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'merge' && fnArgs.length === 9) {
+else if (fn === 'merge' && fnArgs.length === 5) {
   callMerge(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });
 }
-else if (fn === 'series' && fnArgs.length === 3) {
-  callSeries(... fnArgs)
-  .then(() => {
-    console.log('Execution completed');
-  });
-}
 else if (fn === 'score' && fnArgs.length > 0 && fnArgs.length < 3) {
   callScore(... fnArgs)
   .then(() => {

package/merge.js

@@ -1,83 +1,33 @@
 /*
   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);
-})();
 
 
 // ########## 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, requester, timeStamp) => {
+  // If a time stamp was specified:
   if (timeStamp) {
     // If it is invalid:
     if (! dateOf(timeStamp)) {
@@ -86,77 +36,77 @@ 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.creationTimeStamp = getNowStamp();
   protoJob.timeStamp = timeStamp;
-  protoJob.standard = standard || 'only';
-  protoJob.observe = observe || false;
   // 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(2);
   // 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 +134,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": "22.1.0",
+  "version": "23.1.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

@@ -73,7 +73,6 @@ exports.script = (id, issues = null, ... issueIDs) => {
       timeLimit: 30 + (10 * issueIDs.length || 30 * toolIDs.length),
       standard: 'only',
       observe: true,
-      timeStamp: '',
       acts: [
         {
           "type": "placeholder",
@@ -99,7 +98,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;
       }

package/series.js

@@ -1,72 +0,0 @@
-/*
-  series.js
-  Generates a series of Testaro jobs.
-  Arguments:
-    0. Initial job.
-    1. Job count.
-    2. Time interval in minutes.
-*/
-
-// ########## FUNCTIONS
-
-// Scores the specified raw reports.
-exports.series = (job, count, interval) => {
-  // If the arguments are valid:
-  if (
-    typeof job === 'object'
-    && count
-    && typeof count === 'number'
-    && count === Math.floor(count)
-    && count > 1
-    && interval
-    && typeof interval === 'number'
-    && interval === Math.floor(interval)
-    && interval > 0
-  ) {
-    // Get a copy of the initial job.
-    const template = JSON.parse(JSON.stringify(job));
-    // If it has an ID:
-    const jobID = template.id;
-    if (jobID) {
-      // If the ID specifies a valid time:
-      const s = jobID.slice(0, 11);
-      const dateSpec = `20${s[0]}${s[1]}-${s[2]}${s[3]}-${s[4]}${s[5]}`;
-      const timeSpec = `${s[7]}${s[8]}:${s[9]}${s[10]}`;
-      const dateTimeSpec = `${dateSpec}T${timeSpec}Z`;
-      const start = new Date(dateTimeSpec);
-      const startNum = start.valueOf();
-      if (startNum) {
-        // Initialize the series.
-        const series = [];
-        // For each job required:
-        for (let i = 0; i < count; i++) {
-          // Create it.
-          const nextJob = JSON.parse(JSON.stringify(template));
-          nextJob.sources.series = nextJob.id;
-          // Revise its ID.
-          const nextDate = new Date(startNum + i * interval * 60000);
-          const nextTimeStamp = nextDate.toISOString().slice(2, 16).replace(/[-:]/g, '');
-          nextJob.id = nextJob.id.replace(/^[^-]+/, nextTimeStamp);
-          // Add the job to the series.
-          series.push(nextJob);
-        }
-        return series;
-      }
-      // Otherwise, i.e. if it does not specify a valid time:
-      else {
-        // Report this.
-        console.log('ERROR: Initial job ID starts with an invalid time specification');
-      }
-    }
-    // Otherwise, i.e. if it has no ID:
-    else {
-      // Report this.
-      console.log('ERROR: Initial job has no ID');
-    }
-  }
-  // Otherwise, i.e. if they are invalid:
-  else {
-    // Report this.
-    console.log('ERROR: Arguments invalid');
-  }
-};

package/validation/series/job.json

@@ -1,37 +0,0 @@
-{
-  "id": "231120T155027-mon-example",
-  "what": "Job for series validation",
-  "strict": true,
-  "timeLimit": 10,
-  "acts": [
-    {
-      "type": "launch",
-      "which": "chromium",
-      "url": "https://example.com",
-      "what": "Example of web page",
-      "startTime": 1662474496075,
-      "endTime": 1662474496453
-    },
-    {
-      "type": "test",
-      "which": "testaro",
-      "url": "https://example.com",
-      "withItems": false,
-      "rules": [
-        "y",
-        "bulk"
-      ]
-    }
-  ],
-  "sources": {
-    "script": "mon",
-    "batch": "target",
-    "target": {
-      "id": "example",
-      "what": "Example of web page"
-    },
-    "requester": "user@domain.tld"
-  },
-  "creationTime": "2023-11-20T15:50:27",
-  "timeStamp": "231120T155027"
-}

package/validation/series/validate.js

@@ -1,78 +0,0 @@
-/*
-  validate.js
-  Validates series module.
-*/
-
-// ########## IMPORTS
-
-// Function to process files.
-const fs = require('fs/promises');
-// Function to generate a job series.
-const {series} = require('../../series');
-
-// ########## FUNCTIONS
-
-// Validates the series module.
-const validate = async () => {
-  // Get the job.
-  const jobJSON = await fs.readFile(`${__dirname}/job.json`, 'utf8');
-  const job = JSON.parse(jobJSON);
-  // Generate the series.
-  const jobs = series(job, 3, 5);
-  // Validate the series.
-  if (Array.isArray(jobs) && jobs.length === 3) {
-    console.log('Success: The count of jobs is correct');
-  }
-  else {
-    console.log('ERROR: The jobs are not an array of length 3');
-    return;
-  }
-  const job0 = jobs[0];
-  if (
-    job.id
-    && job.id === '240223T0815-mon-example'
-    && job0.id === job.id
-    && job0.sources
-    && job0.sources.series
-    && job0.sources.series === job.id
-  ) {
-    console.log('Success: The first job has the correct id and sources.series');
-  }
-  else {
-    console.log('ERROR: The first job has an incorrect id or sources.series');
-    return;
-  }
-  const job1 = jobs[1];
-  const job2 = jobs[2];
-  if (
-    job2.id
-    && job2.id === '240223T0825-mon-example'
-    && job2.sources
-    && job2.sources.series
-    && job2.sources.series === '240223T0815-mon-example'
-  ) {
-    console.log('Success: The third job has the correct id and sources.series');
-  }
-  else {
-    console.log('ERROR: The first job has an incorrect id or sources.series');
-    return;
-  }
-  if (
-    job1.acts
-    && job1.acts.length === 3
-    && job1.acts[2].rules
-    && job1.acts[2].rules.length === 2
-    && job2.acts
-    && job2.acts.length === 3
-    && job2.acts[2].rules
-    && job2.acts[2].rules.length === 2
-    && job2.acts[2].rules[1] === job1.acts[2].rules[1]
-  ) {
-    console.log('Success: The second and third jobs invoke the same rule');
-  }
-  else {
-    console.log('ERROR: The second and third job do not invoke the same rule');
-    return;
-  }
-};
-validate();