testilo 22.1.0 → 23.0.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,16 +59,27 @@ 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 3 items:
+- An ID
+- 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
+[
+  ['w3c', 'World Wide Web Consortium', 'https://www.w3.org/'],
+  ['moz', '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/
@@ -128,9 +149,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:
 
@@ -144,6 +167,9 @@ Here is a script:
   standard: 'also',
   observe: false,
   timeStamp: '240115T1200',
+  requester: 'you@yourdomain.com',
+  urlPrefix: '/file/reports',
+  urlSuffix: '.json',
   acts: [
     {
       type: 'placeholder',
@@ -169,13 +195,16 @@ 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.
+- `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`.
 - `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.
@@ -207,22 +236,22 @@ The `batch()` function of the `batch` module generates a batch and returns it as
 
 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 +269,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,41 +284,40 @@ 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.
+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,
+  timeStamp: '240115T1200',
   acts: [
     {
       type: 'launch',
@@ -323,15 +351,45 @@ 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'
+    },
+    {
+      type: 'url',
+      which: 'https://acmeclothes.com/login.html',
+      what: 'Acme Clothes login page'
+    },
+    {
+      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: {
@@ -341,34 +399,22 @@ Suppose you ask for a merger of the above batch and script, **without** the isol
       id: 'acme',
       what: 'Acme Clothes'
     },
-    requester: 'you@yourdomain.tld'
+    requester: 'you@yourdomain.tld',
+    url: '/file/reports/240115T1200-4Rw-acme.json'
   },
-  creationTime: '2023-11-20T15:50:27',
-  timeStamp: '231120T155314'
+  creationTime: '2023-11-20T15:50:27'
 }
 ```
 
 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.
 
 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 +425,25 @@ 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, isolate, standard, isGranular, timeStamp, 'file/reports/', '.json'
+);
 ```
 
-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 9 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`.
 
 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,76 +451,29 @@ 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`
+- 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 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
+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.
-- `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.
+- `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.
 
 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.
+The `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `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`
-
-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
-
-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.
-
-#### 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”.
-
 ## Report scoring
 
 ### Introduction

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.
@@ -99,29 +97,6 @@ const callMerge = async (
     `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');
-  }
-};
 // Gets selected reports.
 const getReports = async (type, selector = '') => {
   const allFileNames = await fs.readdir(`${reportDir}/${type}`);
@@ -253,12 +228,6 @@ else if (fn === 'merge' && fnArgs.length === 9) {
     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/package.json

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

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();