testaro 4.1.1 → 4.2.1

package/README.md

@@ -66,6 +66,7 @@ Some of the dependencies of Testaro are published as Github packages. Installing
     //npm.pkg.github.com/:username=abc
     //npm.pkg.github.com/:_authToken=xyz
     ```
+
 Once you have done that, you can install Testaro as you would install any `npm` package.
 
 ## Payment
@@ -383,36 +384,40 @@ You may wish to have Testaro perform the same sequence of tests on multiple web
 }
 ```
 
-With a batch, you can execute a single statement to run a script multiple times, one per host. On each call, Testaro takes one of the hosts in the batch and substitutes it for each host specified in a `url` command of the script. Testaro thereby creates and sequentially runs multiple scripts.
+With a batch, you can execute a single statement to run a script multiple times, one per host. On each call, Testaro takes one of the hosts in the batch and substitutes it for each host specified in a `url` command of the script. The result is a _host script_. Testaro sequentially runs all of those host scripts.
+
+## Samples
+
+The `samples` directory contains examples of scripts and batches. If you wish to use them in their current locations, you can give `SCRIPTDIR` the value `'samples/scripts'` and `BATCHDIR` the value `'samples/batches'`. Then execute `node create sss` or `node create sss bbb` to run the `sss` script alone or with the `bbb` batch (e.g., `node create simple weborgs`). The `create` module will create a job, run the script or host scripts, and save the report(s) in the directory that you have specified with the `REPORTDIR` environment variable.
 
 ## Execution
 
 ### Invocation
 
-There are two methods for using Testaro.
+There are three methods for using Testaro.
 
 #### Low-level
 
-Create a report object like this:
+A module in this package can invoke Testaro with this pattern:
 
 ```javascript
 const report = {
-  id: '',
   script: {…},
   log: [],
   acts: []
 };
+const {handleRequest} = require('./run');
+handleRequest(report)
+.then(() => …);
 ```
 
 Replace `{…}` with a script object, like the example script shown above. The low-level method does not allow the use of batches.
 
-Then execute the `run` module with the `report` object as an argument.
-- Another Node.js package that has Testaro as a dependency can execute `require('testaro').run(report)`.
-- In a command environment with the Testaro project directory as the current directory, you can execute `node run report`.
+The argument of `require` is a path relative to the directory of the module in which this code appears. If the module is in a subdirectory, `./run` will need to be revised. In an executor within `validation/executors`, it must be revised to `../../run`.
 
-Either statement will make Testaro run the script and populate the `log` and `acts` arrays of the `report` object. When Testaro finishes, the `log` and `acts` properties will contain the results.
+Another Node.js package that has Testaro as a dependency can execute the same statements, except changing `'./run'` to `'testaro/run'`.
 
-You or a dependent package can then save or further process the `report` object as desired.
+Testaro will run the script and populate the `log` and `acts` arrays of the `report` object. When Testaro finishes, the `log` and `acts` properties will contain the results. The final statement can further process the `report` object as desired in the `then` callback.
 
 #### High-level
 
@@ -421,52 +426,109 @@ Make sure that you have defined these environment variables, with absolute or re
 - `BATCHDIR`
 - `REPORTDIR`
 
-Relative paths must be relative to the Testaro project directory. For example, if the script directory is `scripts` in a `testing` directory that is a sibling of the Testaro directory, then `SCRIPTDIR` must have the value `../testing/scripts`.
+Relative paths must be relative to the Testaro project directory. For example, if the script directory is `scripts` in a `testing` directory that is a sibling of the Testaro directory, then a relative-path `SCRIPTDIR` must have the value `../testing/scripts`.
 
 Also ensure that Testaro can read all those directories and write to `REPORTDIR`.
 
 Place a script into `SCRIPTDIR` and, optionally, a batch into `BATCHDIR`. Each should be named `idValue.json`, where `idValue` is replaced with the value of its `id` property. That value must consist of only lower-case ASCII letters and digits.
 
-Then execute the statement `node job scriptID` or `node job scriptID batchID`, replacing `scriptID` and `batchID` with the `id` values of the script and the batch, respectively.
+Then execute the statement `node high scriptID` or `node high scriptID batchID`, replacing `scriptID` and `batchID` with the `id` values of the script and the batch, respectively.
 
-The `job` module will call the `run` module on the script, or, if there is a batch, will create multiple scripts, one per host, and sequentially call the `run` module on each script. The results will be saved in report files in the `REPORTDIR` directory.
+The `high` module will call the `runJob` function of the `create` module, which in turn will call the `handleRequest` function of the `run` module. The results will be saved in report files in the `REPORTDIR` directory.
 
-If there is no batch, the report file will be named with a unique timestamp, suffixed with a `.json` extension. If there is a batch, then the base of each file’s name will be the same timestamp, suffixed with `-hostID`, where `hostID` is the value of the `id` property of the `host` object in the batch file. For example, if you execute `node job script01 wikis`, you might get these report files deposited into `REPORTDIR`:
+If there is no batch, the report file will be named with a unique timestamp, suffixed with a `.json` extension. If there is a batch, then the base of each report file’s name will be the same timestamp, suffixed with `-hostID`, where `hostID` is the value of the `id` property of the `host` object in the batch file. For example, if you execute `node create script01 wikis`, you might get these report files deposited into `REPORTDIR`:
 - `enp46j-wikipedia.json`
 - `enp45j-wiktionary.json`
 - `enp45j-wikidata.json`
 
+#### Watch
+
+In watch mode, Testaro periodically checks for a job to be run by it, containing a script and, optionally, a batch. When such a job exists, Testaro runs the script, or uses the batch to create a set of host scripts and sequentially runs them. After running the script or each host script, Testaro converts the report to JSON and disposes of it as specified.
+
+Testaro checks periodically. The interval between checks, in seconds, is specified by an `INTERVAL` environment variable.
+
+After Testaro starts watching, its behavior depends on the environment variable `WATCH_FOREVER`. If its value is `true`, watching continues indefinitely. If its value is `false` or it has no value, watching stops after the first job is found and run.
+
+To make Testaro start watching, execute the statement `node watch`.
+
+There are two ways for Testaro to watch for jobs.
+
+##### Directory watch
+
+With directory watch, Testaro checks whether a particular directory in its host’s filesystem contains a job file. A job file is a JSON-format file named `abc.json` representing an object like this:
+
+```json
+{
+  "script": {…},
+  "batch": {…}
+}
+```
+
+The `batch` property is optional. The value `abc` may be replaced with any string of lower-case ASCII letters and digits.
+
+When Testaro finds job files in the directory, Testaro runs the first job, writes the report(s) into the report directory, and moves the job file into the ex-jobs directory.
+
+Testaro suspends checking while it is running any job. Therefore, even though the currently running job file remains in `JOBDIR`, Testaro will not try to run it again.
+
+Since Testaro runs the first job (i.e. the job whose name is first in ASCII order), whoever populates the directory with job files has control over the order in which Testaro runs them. For example, to force a new job to be run before the already waiting jobs, one can give it a filename that comes before that of the first waiting job.
+
+In order to make directory watching possible, you must define these environment variables:
+- `WATCH_TYPE=dir`
+- `INTERVAL`
+- `WATCH_FOREVER` (`=true` or `=false`)
+- `REPORTDIR`
+- `JOBDIR`
+- `EXJOBDIR`
+
+##### Network watch
+
+With network watch, Testaro asks a particular API whether it has any jobs for the current instance of Testaro, identified by an authorization code. If the response is a JSON representation of an object satisfying the same requirements as given above under “Directory watch”, Testaro runs the job and sends the report(s) to the API.
+
+Thus, if there are multiple jobs queued for the Testaro instance, the API is responsible for choosing one of them to send in response.
+
+When the API receives the reports, it can dispose of them as desired. Each report is a JSON representation of an object, which has these identification properties:
+- `jobID`
+- `timeStamp`
+- `id`
+
+The `jobID` property can be used for an association between each report and the job that it arose from. The `timeStamp` property can be used for an association of all the reports in a batched job. And the `id` property (which begins with the time stamp) is unique to each report.
+
+In order to make network watching possible, you must define these environment variables:
+- `WATCH_TYPE=net`
+- `INTERVAL`
+- `WATCH_FOREVER` (`=true` or `=false`)
+- `PROTOCOL` (`=http` or `=https`)
+- `JOB_URL` (not including the authorization code)
+- `REPORT_URL` (not including the authorization code)
+
 ### Environment variables
 
 As mentioned above, using the high-level method to run Testaro jobs requires `SCRIPTDIR`, `BATCHDIR`, and `REPORTDIR` environment variables.
 
-If a `tenon` test is included in the script, environment variables named `TESTARO_TENON_USER` and `TESTARO_TENON_PASSWORD` must exist, with your Tenon username and password, respectively, as their values.
+If a `tenon` test is included in the script, environment variables named `TENON_USER` and `TENON_PASSWORD` must exist, with your Tenon username and password, respectively, as their values.
 
-If a `wave` test is included in the script, an environment variable named `TESTARO_WAVE_KEY` must exist, with your WAVE API key as its value.
+If a `wave` test is included in the script, an environment variable named `WAVE_KEY` must exist, with your WAVE API key as its value.
 
 The `text` command can interpolate the value of an environment variable into text that it enters on a page, as documented in the `commands.js` file.
 
-Before executing a Testaro script, you can optionally also set the environment variables `TESTARO_DEBUG` (to `'true'` or anything else) and/or `TESTARO_WAITS` (to a non-negative integer). The effects of these variables are described in the `index.js` file.
+Before executing a Testaro script, you can optionally also set the environment variables `DEBUG` (to `'true'` or anything else) and/or `WAITS` (to a non-negative integer). The effects of these variables are described in the `index.js` file.
 
 You may store these environment variables in an untracked `.env` file if you wish, and Testaro will recognize them.
 
 ## Validation
 
-### Samples
-
-The `samples` directory contains scripts and a batch that you can use to test Testaro with with the high-level method, by giving `SCRIPTDIR` the value `'samples/scripts'` and `BATCHDIR` the value `'samples/batches'`. Do to this, you must also define `REPORTDIR`. Then execute `node job simple` or `node job simple weborgs` to run the `simple` script alone or with the `weborgs` batch.
-
 ### Validators
 
-Testaro can be validated with the _executors_ located in the `validation/executors` directory. Executors are modules that run Testaro with the low-level method and write the results to the standard output.
+Testaro and its custom tests can be validated with the _executors_ located in the `validation/executors` directory.
 
 The executors are:
 
-- `app`: reports whether Testaro runs correctly with a script
-- `test`: runs the `simple` sample script
-- `tests`: makes Testaro perform each custom test and reports whether the results are correct
-
-There are no executors for validating the test packages.
+- `low`: validates low-level invocation
+- `high1`: validates high-level invocation of a script without a batch
+- `high2`: validates high-level invocation of a script with a batch
+- `watchDir`: validates directory watching
+- `watchNet`: validates network watching
+- `tests`: validates all the custom tests (not the test packages)
 
 To execute any executor `xyz`, call it with the statement `node validation/executors/xyz`.
 
@@ -543,7 +605,6 @@ Further development is contemplated, is taking place, or is welcomed, on:
 - autocomplete attributes
 - inclusion of other test packages, such as:
    - FAE (https://github.com/opena11y/evaluation-library)
-   - Tenon
 
 ## Corrections
 

package/batchify.js

@@ -0,0 +1,24 @@
+/*
+  batchify.js
+  Creates a set of scripts from a script and a batch.
+*/
+
+// Converts a script to a batch-based array of scripts.
+exports.batchify = (script, batch, timeStamp) => {
+  const {hosts} = batch;
+  const specs = hosts.map(host => {
+    const newScript = JSON.parse(JSON.stringify(script));
+    newScript.commands.forEach(command => {
+      if (command.type === 'url') {
+        command.which = host.which;
+        command.what = host.what;
+      }
+    });
+    const spec = {
+      id: `${timeStamp}-${host.id}`,
+      script: newScript
+    };
+    return spec;
+  });
+  return specs;
+};

package/{job.js → create.js}

@@ -1,6 +1,6 @@
 /*
-  job.js
-  Manages jobs.
+  create.js
+  Creates and runs a file-based job and writes a report file.
 */
 
 // ########## IMPORTS
@@ -10,6 +10,8 @@ require('dotenv').config();
 // Module to read and write files.
 const fs = require('fs/promises');
 const {handleRequest} = require('./run');
+// Module to convert a script and a batch to a batch-based array of scripts.
+const {batchify} = require('./batchify');
 
 // ########## CONSTANTS
 const scriptDir = process.env.SCRIPTDIR;
@@ -18,26 +20,7 @@ const reportDir = process.env.REPORTDIR;
 
 // ########## FUNCTIONS
 
-// Converts a script to a batch-based array of scripts.
-const batchify = (script, batch, timeStamp) => {
-  const {hosts} = batch;
-  const specs = hosts.map(host => {
-    const newScript = JSON.parse(JSON.stringify(script));
-    newScript.commands.forEach(command => {
-      if (command.type === 'url') {
-        command.which = host.which;
-        command.what = host.what;
-      }
-    });
-    const spec = {
-      id: `${timeStamp}-${host.id}`,
-      script: newScript
-    };
-    return spec;
-  });
-  return specs;
-};
-// Runs a no-batch script.
+// Runs one script and writes a report file.
 const runHost = async (id, script) => {
   const report = {
     id,
@@ -49,8 +32,8 @@ const runHost = async (id, script) => {
   const reportJSON = JSON.stringify(report, null, 2);
   await fs.writeFile(`${reportDir}/${id}.json`, reportJSON);
 };
-// Runs a job.
-exports.job = async (scriptID, batchID) => {
+// Runs a file-based job and writes a report file for the script or each host.
+exports.runJob = async (scriptID, batchID) => {
   if (scriptID) {
     try {
       const scriptJSON = await fs.readFile(`${scriptDir}/${scriptID}.json`, 'utf8');
@@ -77,16 +60,15 @@ exports.job = async (scriptID, batchID) => {
         // Run the script and save the result with a timestamp ID.
         await runHost(timeStamp, script);
       }
+      return timeStamp;
     }
     catch(error) {
       console.log(`ERROR: ${error.message}\n${error.stack}`);
+      return null;
     }
   }
   else {
     console.log('ERROR: no script specified');
+    return null;
   }
 };
-
-// ########## OPERATION
-
-exports.job(process.argv[2], process.argv[3]);

package/high.js

@@ -0,0 +1,11 @@
+// high.js
+// Invokes Testaro with the high-level method.
+
+const {runJob} = require('./create');
+const scriptID = process.argv[2];
+const batchID = process.argv[3];
+const run = async (scriptID, batchID) => {
+  const timeStamp = await runJob(scriptID, batchID);
+  console.log(`Reports in ${process.env.REPORTDIR}; ID base ${timeStamp}`);
+};
+run(scriptID, batchID);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "4.1.1",
+  "version": "4.2.1",
   "description": "Automation of accessibility testing",
   "main": "index.js",
   "scripts": {

package/run.js

@@ -9,9 +9,9 @@ require('dotenv').config();
 const {commands} = require('./commands');
 // ########## CONSTANTS
 // Set DEBUG environment variable to 'true' to add debugging features.
-const debug = process.env.TESTARO_DEBUG === 'true';
+const debug = process.env.DEBUG === 'true';
 // Set WAITS environment variable to a positive number to insert delays (in ms).
-const waits = Number.parseInt(process.env.TESTARO_WAITS) || 0;
+const waits = Number.parseInt(process.env.WAITS) || 0;
 // CSS selectors for targets of moves.
 const moves = {
   button: 'button',
@@ -209,9 +209,8 @@ const isValidLog = log => Array.isArray(log) && ! log.length;
 // Validates a report object.
 const isValidReport = async report => {
   if (report) {
-    const {id, script, log, acts} = report;
-    return id
-    && isValidScript(script)
+    const {script, log, acts} = report;
+    return isValidScript(script)
     && isValidLog(log)
     && isValidActs(acts);
   }
@@ -700,7 +699,7 @@ const doActs = async (report, actIndex, page) => {
             // If the act is a revelation:
             if (act.type === 'reveal') {
               // Make all elements in the page visible.
-              await require('./procs/test/allVis').allVis(page);
+              await require('./procs/allVis').allVis(page);
               act.result = 'All elements visible.';
             }
             // Otherwise, if the act is a tenon request:
@@ -742,8 +741,8 @@ const doActs = async (report, actIndex, page) => {
                       });
                     }
                   );
-                  const tenonUser = process.env.TESTARO_TENON_USER;
-                  const tenonPassword = process.env.TESTARO_TENON_PASSWORD;
+                  const tenonUser = process.env.TENON_USER;
+                  const tenonPassword = process.env.TENON_PASSWORD;
                   const postData = JSON.stringify({
                     username: tenonUser,
                     password: tenonPassword
@@ -1244,11 +1243,13 @@ exports.handleRequest = async report => {
     if (! report.id) {
       report.id = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
     }
+    // Add a time stamp to the report.
+    report.timeStamp = report.id.replace(/-.+/, '');
     // Add the script commands to the report as its initial acts.
     report.acts = JSON.parse(JSON.stringify(report.script.commands));
     // Inject url acts where necessary to undo DOM changes.
     injectURLActs(report.acts);
-    // Perform the script, asynchronously adding to the log and report.
+    // Perform the acts, asynchronously adding to the log and report.
     await doScript(report);
   }
   else {

package/samples/scripts/simple.json

@@ -1,4 +1,5 @@
 {
+  "id": "simple",
   "what": "Test example.com with bulk",
   "strict": true,
   "commands": [
@@ -14,7 +15,8 @@
     },
     {
       "type": "test",
-      "which": "bulk"
+      "which": "bulk",
+      "what": "bulk"
     }
   ]
 }

package/samples/scripts/tenon.json

@@ -1,4 +1,5 @@
 {
+  "id": "tenon",
   "what": "Test Wikipedia with tenon",
   "strict": true,
   "commands": [

package/tests/focInd.js

@@ -12,7 +12,7 @@
 exports.reporter = async (page, withItems, revealAll) => {
   // If required, make all elements visible.
   if (revealAll) {
-    await require('../procs/test/allVis').allVis(page);
+    await require('../procs/allVis').allVis(page);
   }
   // Get data on the focusable visible elements with and without indicators.
   const data = await page.$$eval('body *:visible', (elements, withItems) => {

package/tests/linkUl.js

@@ -9,7 +9,7 @@
 */
 exports.reporter = async (page, withItems) => {
   // Identify the links in the page, by type.
-  const linkTypes = await require('../procs/test/linksByType').linksByType(page);
+  const linkTypes = await require('../procs/linksByType').linksByType(page);
   return await page.evaluate(args => {
     const withItems = args[0];
     const linkTypes = args[1];

package/tests/menuNav.js

@@ -77,7 +77,7 @@ exports.reporter = async (page, withItems) => {
   if (menus.length) {
     // FUNCTION DEFINITIONS START
     // Returns text associated with an element.
-    const {allText} = require('../procs/test/allText');
+    const {allText} = require('../procs/allText');
     // Returns the index of the focused menu item in an array of menu items.
     const focusedMenuItem = async menuItems => await page.evaluate(menuItems => {
       const focus = document.activeElement;

package/tests/radioSet.js

@@ -12,7 +12,7 @@ exports.reporter = async (page, withItems) => {
   // If itemization is required:
   if (withItems) {
     // Add the body of the textOf function as a string to the array.
-    const textOfBody = await fs.readFile(`${__dirname}/../procs/test/textOf.txt`, 'utf8');
+    const textOfBody = await fs.readFile(`${__dirname}/../procs/textOf.txt`, 'utf8');
     args.push(textOfBody);
   }
   // Get the result data.

package/tests/styleDiff.js

@@ -7,7 +7,7 @@
 */
 exports.reporter = async (page, withItems) => {
   // Get an object with arrays of block and inline links as properties.
-  const linkTypes = await require('../procs/test/linksByType').linksByType(page);
+  const linkTypes = await require('../procs/linksByType').linksByType(page);
   return await page.$eval('body', (body, args) => {
     const withItems = args[0];
     const linkTypes = args[1];

package/tests/tabNav.js

@@ -74,7 +74,7 @@ exports.reporter = async (page, withItems) => {
   if (tabLists.length) {
     // FUNCTION DEFINITIONS START
     // Returns text associated with an element.
-    const {allText} = require('../procs/test/allText');
+    const {allText} = require('../procs/allText');
     // Returns the index of the focused tab in an array of tabs.
     const focusedTab = async tabs => await page.evaluate(tabs => {
       const focus = document.activeElement;

package/tests/wave.js

@@ -6,7 +6,7 @@
 */
 const https = require('https');
 exports.reporter = async (page, reportType) => {
-  const waveKey = process.env.TESTARO_WAVE_KEY;
+  const waveKey = process.env.WAVE_KEY;
   // Get the data from a WAVE test.
   const data = await new Promise(resolve => {
     https.get(

package/validation/exJobs/README.md

@@ -0,0 +1,3 @@
+# exJobs
+
+Directory into which executor `watchDir` archives jobs.

package/validation/executors/high1.js

@@ -0,0 +1,32 @@
+// high1.js
+// Validator for high-level invocation of Testaro without a batch.
+
+const fs = require('fs/promises');
+process.env.SCRIPTDIR = 'samples/scripts';
+process.env.REPORTDIR = 'temp';
+const {runJob} = require('../../create');
+const validate = async (scriptID) => {
+  const timeStamp = await runJob(scriptID);
+  try {
+    const reportJSON = await fs.readFile(`${__dirname}/../../temp/${timeStamp}.json`);
+    const report = JSON.parse(reportJSON);
+    const {log, acts} = report;
+    if (log.length !== 2) {
+      console.log(
+        `Failure: log length is ${log.length} instead of 2 (see temp/${timeStamp}.json})`
+      );
+    }
+    else if (acts.length !== 3) {
+      console.log(
+        `Failure: acts length is ${acts.length} instead of 3 (see temp/${timeStamp}.json})`
+      );
+    }
+    else {
+      console.log(`Success (report is in temp/${timeStamp}.json)`);
+    }
+  }
+  catch(error) {
+    console.log(`ERROR: ${error.message}`);
+  }
+};
+validate('simple');

package/validation/executors/high2.js

@@ -0,0 +1,37 @@
+// high2.js
+// Validator for high-level invocation of Testaro with a batch.
+
+const fs = require('fs/promises');
+process.env.SCRIPTDIR = 'samples/scripts';
+process.env.BATCHDIR = 'samples/batches';
+process.env.REPORTDIR = 'temp';
+const {runJob} = require('../../create');
+const validate = async (scriptID, batchID) => {
+  const timeStamp = await runJob(scriptID, batchID);
+  try {
+    const tempFileNames = await fs.readdir(`${__dirname}/../../temp`);
+    const reportFileNames = tempFileNames.filter(fileName => fileName.startsWith(timeStamp));
+    for (const fileName of reportFileNames) {
+      const reportJSON = await fs.readFile(`${__dirname}/../../temp/${fileName}`);
+      const report = JSON.parse(reportJSON);
+      const {log, acts} = report;
+      if (log.length !== 2) {
+        console.log(
+          `Failure: log length is ${log.length} instead of 2 (see temp/${fileName})`
+        );
+      }
+      else if (acts.length !== 3) {
+        console.log(
+          `Failure: acts length is ${acts.length} instead of 3 (see temp/${fileName})`
+        );
+      }
+      else {
+        console.log(`Success (report is in temp/${fileName})`);
+      }
+    }
+  }
+  catch(error) {
+    console.log(`ERROR: ${error.message}`);
+  }
+};
+validate('simple', 'weborgs');

package/validation/executors/low.js

@@ -0,0 +1,31 @@
+// low.js
+// Validator for low-level invocation of Testaro.
+
+const fs = require('fs/promises');
+const getSampleScript = async scriptID => {
+  const scriptJSON = await fs.readFile(`${__dirname}/../../samples/scripts/${scriptID}.json`);
+  return JSON.parse(scriptJSON);
+};
+const validate = async () => {
+  const script = await getSampleScript('simple');
+  const report = {
+    script,
+    log: [],
+    acts: []
+  };
+  const {handleRequest} = require('../../run');
+  await handleRequest(report);
+  const {log, acts} = report;
+  if (log.length !== 2) {
+    console.log(`Failure: log length is ${log.length} instead of 2`);
+    console.log(JSON.stringify(log, null, 2));
+  }
+  else if (acts.length !== 3) {
+    console.log(`Failure: acts length is ${acts.length} instead of 3`);
+    console.log(JSON.stringify(acts, null, 2));
+  }
+  else {
+    console.log('Success');
+  }
+};
+validate();

package/validation/executors/watchDir.js

@@ -0,0 +1,17 @@
+// watchDir.js
+// Validator for directory watching.
+
+const fs = require('fs/promises');
+process.env.WATCH_TYPE = 'dir';
+process.env.INTERVAL = 5;
+process.env.REPORTDIR = 'temp';
+process.env.JOBDIR = 'validation/jobs';
+process.env.EXJOBDIR = 'validation/exJobs';
+process.env.WATCH_FOREVER = false;
+// Start checking for jobs every 5 seconds.
+require('../../watch');
+// Copy a job into JOBDIR after 7 seconds.
+setTimeout(() => {
+  fs.copyFile(`${__dirname}/../protoJobs/val1.json`, `${__dirname}/../jobs/val1.json`);
+  console.log('Job copied into job directory after 7 seconds');
+}, 7000);