testaro 6.0.4 → 8.0.1

package/do.js

@@ -0,0 +1,62 @@
+/*
+  do.js
+  Invokes Testaro modules with arguments.
+  This is the universal module for use of Testaro from a command line.
+  Arguments:
+    0. function to execute.
+    1+. arguments to pass to the function.
+  Usage examples:
+    node do high script454
+    node do watch dir once 30
+    node do watch net forever 60
+*/
+
+// ########## IMPORTS
+
+// Module to keep secrets.
+require('dotenv').config();
+// Function to process a high-level testing request.
+const {runJob} = require('./high');
+// Function to watch for jobs.
+const {cycle} = require('./watch');
+
+// ########## CONSTANTS
+
+const fn = process.argv[2];
+const fnArgs = process.argv.slice(2);
+const reportDir = process.env.REPORTDIR;
+
+// ########## FUNCTIONS
+
+// Fulfills a high-level testing request.
+const doHigh = async scriptID => {
+  await runJob(scriptID);
+  console.log(`Job completed and report ${scriptID}.json saved in ${reportDir}`);
+};
+// Starts a watch.
+const doWatch = async (isDirWatch, isForever, interval) => {
+  console.log(
+    `Starting a ${isForever ? 'repeating' : 'one-time'} ${isDirWatch ? 'directory' : 'network'} watch`
+  );
+  await cycle(isDirWatch, isForever, interval);
+  console.log('Watching ended');
+};
+
+// ########## OPERATION
+
+// Execute the requested function.
+if (fn === 'high' && fnArgs.length === 1) {
+  doHigh(fnArgs)
+  .then(() => {
+    console.log('Execution completed');
+  });
+}
+else if (fn === 'watch' && fnArgs.length === 3) {
+  doWatch(... fnArgs)
+  .then(() => {
+    console.log('Execution completed');
+  });
+}
+else {
+  console.log('ERROR: Invalid statement');
+}

package/high.js

@@ -17,7 +17,6 @@ const {doJob} = require('./run');
 
 const scriptDir = process.env.SCRIPTDIR;
 const reportDir = process.env.REPORTDIR;
-const scriptID = process.argv[2];
 
 // ########## VARIABLES
 
@@ -27,7 +26,7 @@ let timeLimit = 300;
 // ########## FUNCTIONS
 
 // Performs a file-based job and writes a report file.
-const runJob = async scriptID => {
+exports.runJob = async scriptID => {
   try {
     const scriptJSON = await fs.readFile(`${scriptDir}/${scriptID}.json`, 'utf8');
     const script = JSON.parse(scriptJSON);
@@ -35,35 +34,17 @@ const runJob = async scriptID => {
     if (! script.timeLimit) {
       script.timeLimit = timeLimit;
     }
-    // Identify the start time and a timestamp.
-    const timeStamp = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
-    // Run the script and record the report with the timestamp as name base.
-    const id = `${timeStamp}-${scriptID}`;
+    // Run the script and record the report.
     const report = {
-      id,
-      log: [],
       script,
       acts: []
     };
     await doJob(report);
     const reportJSON = JSON.stringify(report, null, 2);
-    await fs.writeFile(`${reportDir}/${id}.json`, reportJSON);
-    console.log(`Report ${timeStamp}-${scriptID}.json recorded in ${process.env.REPORTDIR}`);
+    await fs.writeFile(`${reportDir}/${scriptID}.json`, reportJSON);
+    console.log(`Report ${scriptID}.json recorded in ${process.env.REPORTDIR}`);
   }
   catch(error) {
     console.log(`ERROR running job (${error.message})\n${error.stack}`);
   }
 };
-
-// ########## OPERATION
-
-// If this module was called with a scriptID argument:
-if (scriptID) {
-  // Run the script and write a report.
-  runJob(scriptID);
-}
-// Otherwise, i.e. if it was required by another module:
-else {
-  // Export runJob so the other module can call it.
-  exports.runJob = runJob;
-}

package/package.json

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

package/run.js

@@ -1,6 +1,6 @@
 /*
   run.js
-  testaro main script.
+  Testaro main utility module.
 */
 
 // ########## IMPORTS
@@ -113,14 +113,6 @@ const errorWords = [
 // ########## VARIABLES
 
 // Facts about the current session.
-let logCount = 0;
-let logSize = 0;
-let errorLogCount = 0;
-let errorLogSize = 0;
-let prohibitedCount = 0;
-let visitTimeoutCount = 0;
-let visitRejectionCount = 0;
-let visitLatency = 0;
 let actCount = 0;
 // Facts about the current browser.
 let browser;
@@ -241,33 +233,24 @@ const isValidCommand = command => {
     return false;
   }
 };
-// Validates a script.
-const isValidScript = script => {
-  // Get the script data.
-  const {what, strict, commands} = script;
-  // Return whether the script is valid:
-  return what
-    && typeof strict === 'boolean'
-    && commands
-    && typeof what === 'string'
-    && Array.isArray(commands)
-    && commands[0].type === 'launch'
-    && commands.length > 1
-    && commands[1].type === 'url'
-    && isURL(commands[1].which)
-    && commands.every(command => isValidCommand(command));
-};
-// Validates an initialized reports array.
-const isValidActs = acts => Array.isArray(acts) && ! acts.length;
-// Validates an initialized log array.
-const isValidLog = log => Array.isArray(log) && ! log.length;
 // Validates a report object.
-const isValidReport = async report => {
+const isValidReport = report => {
   if (report) {
-    const {script, log, acts} = report;
-    return isValidScript(script)
-    && isValidLog(log)
-    && isValidActs(acts);
+    // Return whether the report is valid.
+    const {script, acts} = report;
+    const {what, strict, commands} = script;
+    return what
+      && typeof strict === 'boolean'
+      && commands
+      && typeof what === 'string'
+      && Array.isArray(commands)
+      && commands[0].type === 'launch'
+      && commands.length > 1
+      && commands[1].type === 'url'
+      && isURL(commands[1].which)
+      && commands.every(command => isValidCommand(command))
+      && Array.isArray(acts)
+      && ! acts.length;
   }
   else {
     return false;
@@ -276,6 +259,8 @@ const isValidReport = async report => {
 
 // ########## OTHER FUNCTIONS
 
+// Returns a string representing the date and time.
+const nowString = () => (new Date()).toISOString().slice(0, 19);
 // Closes the current browser.
 const browserClose = async () => {
   if (browser) {
@@ -289,7 +274,7 @@ const browserClose = async () => {
 // Returns the first line of an error message.
 const errorStart = error => error.message.replace(/\n.+/s, '');
 // Launches a browser.
-const launch = async typeName => {
+const launch = async (report, typeName) => {
   const browserType = require('playwright')[typeName];
   // If the specified browser type exists:
   if (browserType) {
@@ -343,15 +328,15 @@ const launch = async typeName => {
           console.log(`\n${indentedMsg}`);
           const msgTextLC = msgText.toLowerCase();
           const msgLength = msgText.length;
-          logCount++;
-          logSize += msgLength;
+          report.jobData.logCount++;
+          report.jobData.logSize += msgLength;
           if (errorWords.some(word => msgTextLC.includes(word))) {
-            errorLogCount++;
-            errorLogSize += msgLength;
+            report.jobData.errorLogCount++;
+            report.jobData.errorLogSize += msgLength;
           }
           const msgLC = msgText.toLowerCase();
           if (msgText.includes('403') && (msgLC.includes('status') || msgLC.includes('prohibited'))) {
-            prohibitedCount++;
+            report.jobData.prohibitedCount++;
           }
         });
       });
@@ -459,114 +444,6 @@ const textOf = async (page, element) => {
 };
 // Returns a string with any final slash removed.
 const deSlash = string => string.endsWith('/') ? string.slice(0, -1) : string;
-// Tries to visit a URL.
-const goto = async (page, url, timeout, waitUntil, isStrict) => {
-  if (url.startsWith('file://.')) {
-    url = url.replace('file://', `file://${__dirname}/`);
-  }
-  // Visit the URL.
-  const startTime = Date.now();
-  const response = await page.goto(url, {
-    timeout,
-    waitUntil
-  })
-  .catch(error => {
-    console.log(`ERROR: Visit to ${url} timed out before ${waitUntil} (${errorStart(error)})`);
-    visitTimeoutCount++;
-    return 'error';
-  });
-  visitLatency += Math.round((Date.now() - startTime) / 1000);
-  // If the visit succeeded:
-  if (typeof response !== 'string') {
-    const httpStatus = response.status();
-    // If the response status was normal:
-    if ([200, 304].includes(httpStatus) || url.startsWith('file:')) {
-      // If the browser was redirected in violation of a strictness requirement.
-      const actualURL = page.url();
-      if (isStrict && deSlash(actualURL) !== deSlash(url)) {
-        // Return an error.
-        console.log(`ERROR: Visit to ${url} redirected to ${actualURL}`);
-        return 'redirection';
-      }
-      // Otherwise, i.e. if no prohibited redirection occurred:
-      else {
-        // Press the Escape key to dismiss any modal dialog.
-        await page.keyboard.press('Escape');
-        // Return the response.
-        return response;
-      }
-    }
-    // Otherwise, i.e. if the response status was abnormal:
-    else {
-      // Return an error.
-      console.log(`ERROR: Visit to ${url} got status ${httpStatus}`);
-      visitRejectionCount++;
-      return 'error';
-    }
-  }
-  // Otherwise, i.e. if the visit failed:
-  else {
-    // Return an error.
-    return 'error';
-  }
-};
-// Visits the URL that is the value of the “which” property of an act.
-const visit = async (act, page, isStrict) => {
-  // Identify the URL.
-  const resolved = act.which.replace('__dirname', __dirname);
-  requestedURL = resolved;
-  // Visit it and wait until the network is idle.
-  let response = await goto(page, requestedURL, 15000, 'networkidle', isStrict);
-  // If the visit fails:
-  if (response === 'error') {
-    // Try again until the DOM is loaded.
-    response = await goto(page, requestedURL, 10000, 'domcontentloaded', isStrict);
-    // If the visit fails:
-    if (response === 'error') {
-      // Launch another browser type.
-      const newBrowserName = Object.keys(browserTypeNames)
-      .find(name => name !== browserTypeName);
-      console.log(`>> Launching ${newBrowserName} instead`);
-      await launch(newBrowserName);
-      // Identify its only page as current.
-      page = browserContext.pages()[0];
-      // Try again until the network is idle.
-      response = await goto(page, requestedURL, 10000, 'networkidle', isStrict);
-      // If the visit fails:
-      if (response === 'error') {
-        // Try again until the DOM is loaded.
-        response = await goto(page, requestedURL, 5000, 'domcontentloaded', isStrict);
-        // If the visit fails:
-        if (response === 'error') {
-          // Try again or until a load.
-          response = await goto(page, requestedURL, 5000, 'load', isStrict);
-          // If the visit fails:
-          if (response === 'error') {
-            // Give up.
-            const errorMsg = `ERROR: Attempts to visit ${requestedURL} failed`;
-            console.log(errorMsg);
-            act.result = errorMsg;
-            await page.goto('about:blank')
-            .catch(error => {
-              console.log(`ERROR: Navigation to blank page failed (${error.message})`);
-            });
-            return null;
-          }
-        }
-      }
-    }
-  }
-  // If one of the visits succeeded:
-  if (response) {
-    // Add the resulting URL to the act.
-    if (isStrict && response === 'redirection') {
-      act.error = 'ERROR: Navigation redirected';
-    }
-    act.result = page.url();
-    // Return the page.
-    return page;
-  }
-};
 // Returns a property value and whether it satisfies an expectation.
 const isTrue = (object, specs) => {
   const property = specs[0];
@@ -634,6 +511,9 @@ const wait = ms => {
 };
 // Adds an error result to an act.
 const addError = (act, error, message) => {
+  if (! act.result) {
+    act.result = {};
+  }
   act.result.success = false;
   act.result.error = error;
   act.result.message = message;
@@ -641,6 +521,65 @@ const addError = (act, error, message) => {
     act.result.prevented = true;
   }
 };
+// Visits a URL and returns the response of the server.
+const goTo = async (report, page, url, timeout, waitUntil, isStrict) => {
+  if (url.startsWith('file://')) {
+    url = url.replace('file://', `file://${__dirname}/`);
+  }
+  // Visit the URL.
+  const startTime = Date.now();
+  const response = await page.goto(url, {
+    timeout,
+    waitUntil
+  })
+  .catch(error => {
+    console.log(`ERROR: Visit to ${url} timed out before ${waitUntil} (${errorStart(error)})`);
+    report.jobData.visitTimeoutCount++;
+    return {
+      error: 'timeout'
+    };
+  });
+  report.jobData.visitLatency += Math.round((Date.now() - startTime) / 1000);
+  // If the visit succeeded:
+  if (! response.error) {
+    const httpStatus = response.status();
+    // If the response status was normal:
+    if ([200, 304].includes(httpStatus) || url.startsWith('file:')) {
+      // If the browser was redirected in violation of a strictness requirement:
+      const actualURL = page.url();
+      if (isStrict && deSlash(actualURL) !== deSlash(url)) {
+        // Return an error.
+        console.log(`ERROR: Visit to ${url} redirected to ${actualURL}`);
+        return {
+          exception: 'badRedirection'
+        };
+      }
+      // Otherwise, i.e. if no prohibited redirection occurred:
+      else {
+        // Press the Escape key to dismiss any modal dialog.
+        await page.keyboard.press('Escape');
+        // Return the response.
+        return response;
+      }
+    }
+    // Otherwise, i.e. if the response status was abnormal:
+    else {
+      // Return an error.
+      console.log(`ERROR: Visit to ${url} got status ${httpStatus}`);
+      report.jobData.visitRejectionCount++;
+      return {
+        error: 'badStatus'
+      };
+    }
+  }
+  // Otherwise, i.e. if the visit failed:
+  else {
+    // Return an error.
+    return {
+      error: 'noStatus'
+    };
+  }
+};
 // Recursively performs the acts in a report.
 const doActs = async (report, actIndex, page) => {
   process.on('message', message => {
@@ -700,7 +639,7 @@ const doActs = async (report, actIndex, page) => {
       // Otherwise, if the command is a launch:
       else if (act.type === 'launch') {
         // Launch the specified browser, creating a browser context and a page in it.
-        await launch(act.which);
+        await launch(report, act.which);
         // Identify its only page as current.
         page = browserContext.pages()[0];
       }
@@ -708,8 +647,73 @@ const doActs = async (report, actIndex, page) => {
       else if (page) {
         // If the command is a url:
         if (act.type === 'url') {
-          // Visit it and wait until it is stable.
-          page = await visit(act, page, report.isStrict);
+          // Identify the URL.
+          const resolved = act.which.replace('__dirname', __dirname);
+          requestedURL = resolved;
+          // Visit it and wait until the network is idle.
+          const {strict} = report.script;
+          let response = await goTo(report, page, requestedURL, 15000, 'networkidle', strict);
+          // If the visit fails:
+          if (response.error) {
+            // Try again until the DOM is loaded.
+            response = await goTo(report, page, requestedURL, 10000, 'domcontentloaded', strict);
+            // If the visit fails:
+            if (response.error) {
+              // Launch another browser type.
+              const newBrowserName = Object.keys(browserTypeNames)
+              .find(name => name !== browserTypeName);
+              console.log(`>> Launching ${newBrowserName} instead`);
+              await launch(newBrowserName);
+              // Identify its only page as current.
+              page = browserContext.pages()[0];
+              // Try again until the network is idle.
+              response = await goTo(report, page, requestedURL, 10000, 'networkidle', strict);
+              // If the visit fails:
+              if (response.error) {
+                // Try again until the DOM is loaded.
+                response = await goTo(report, page, requestedURL, 5000, 'domcontentloaded', strict);
+                // If the visit fails:
+                if (response.error) {
+                  // Try again or until a load.
+                  response = await goTo(report, page, requestedURL, 5000, 'load', strict);
+                  // If the visit fails:
+                  if (response.error) {
+                    // Navigate to a blank page instead.
+                    await page.goto('about:blank')
+                    .catch(error => {
+                      console.log(`ERROR: Navigation to blank page failed (${error.message})`);
+                    });
+                  }
+                }
+              }
+            }
+          }
+          // If none of the visits succeeded:
+          if (response.error) {
+            // Report this.
+            report.jobData.aborted = true;
+            report.jobData.abortedAct = actIndex;
+            addError(act, 'failure', 'ERROR: Visits failed');
+            // Quit.
+            actIndex = -2;
+          }
+          // Otherwise, i.e. if the last visit attempt succeeded:
+          else {
+            // If a prohibited redirection occurred:
+            if (response.exception === 'badRedirection') {
+              // Report this.
+              report.jobData.aborted = true;
+              report.jobData.abortedAct = actIndex;
+              addError(act, 'badRedirection', 'ERROR: Navigation illicitly redirected');
+              // Quit.
+              actIndex = -2;
+            }
+            // Add the resulting URL to the act.
+            if (! act.result) {
+              act.result = {};
+            }
+            act.result.url = page.url();
+          }
         }
         // Otherwise, if the act is a wait for text:
         else if (act.type === 'wait') {
@@ -782,10 +786,7 @@ const doActs = async (report, actIndex, page) => {
           )
           .catch(error => {
             console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
-            act.result = {
-              success: false,
-              error: `ERROR waiting for page to be ${act.which}`
-            };
+            addError(act, 'timeout', `ERROR waiting for page to be ${act.which}`);
             actIndex = -2;
           });
           if (actIndex > -2) {
@@ -976,8 +977,8 @@ const doActs = async (report, actIndex, page) => {
                 testReport.result.failureCount = failureCount;
               }
               testReport.result.success = true;
-              report.testTimes.push([act.which, Math.round((Date.now() - startTime) / 1000)]);
-              report.testTimes.sort((a, b) => b[1] - a[1]);
+              report.jobData.testTimes.push([act.which, Math.round((Date.now() - startTime) / 1000)]);
+              report.jobData.testTimes.sort((a, b) => b[1] - a[1]);
               // Add the result object (possibly an array) to the act.
               const resultCount = Object.keys(testReport.result).length;
               act.result = resultCount ? testReport.result : {success: false};
@@ -1220,7 +1221,7 @@ const doActs = async (report, actIndex, page) => {
                   }
                   // Enter the text.
                   await selection.type(act.what);
-                  report.presses += act.what.length;
+                  report.jobData.presses += act.what.length;
                   act.result.success = true;
                   act.result.move = 'entered';
                   // If the input is a search input:
@@ -1252,7 +1253,7 @@ const doActs = async (report, actIndex, page) => {
             else if (act.type === 'press') {
               // Identify the number of times to press the key.
               let times = 1 + (act.again || 0);
-              report.presses += times;
+              report.jobData.presses += times;
               const key = act.which;
               // Press the key.
               while (times--) {
@@ -1407,30 +1408,22 @@ const doActs = async (report, actIndex, page) => {
                 act.result.items = items;
               }
               // Add the totals to the report.
-              report.presses += presses;
-              report.amountRead += amountRead;
+              report.jobData.presses += presses;
+              report.jobData.amountRead += amountRead;
             }
             // Otherwise, i.e. if the act type is unknown:
             else {
               // Add the error result to the act.
-              act.result = {
-                success: false,
-                error: 'badType',
-                message: 'ERROR: invalid command type'
-              };
+              addError(act, 'badType', 'ERROR: Invalid command type');
             }
           }
           // Otherwise, i.e. if redirection is prohibited but occurred:
           else {
             // Add an error result to the act.
-            act.result = {
-              success: false,
-              error: 'redirection',
-              message: `ERROR: Page redirected to (${url})`
-            };
+            addError(act, 'redirection', `ERROR: Page redirected to (${url})`);
           }
         }
-        // Otherwise, i.e. if the required page URL does not exist:
+        // Otherwise, a page URL is required but does not exist, so:
         else {
           // Add an error result to the act.
           addError(act, 'noURL', 'ERROR: Page has no URL');
@@ -1447,60 +1440,18 @@ const doActs = async (report, actIndex, page) => {
     else {
       // Add an error result to the act.
       const errorMsg = `ERROR: Invalid command of type ${act.type}`;
-      act.result = {
-        success: false,
-        error: 'badCommand',
-        message: errorMsg
-      };
       console.log(errorMsg);
+      addError(act, 'badCommand', errorMsg);
       // Quit.
       actIndex = -2;
     }
-    // Perform the remaining acts.
+    // Perform the remaining acts unless the performance of acts has been aborted.
     await doActs(report, actIndex + 1, page);
   }
   else {
     await browserClose();
   }
 };
-// Performs the commands in a script.
-const doScript = async (report) => {
-  // Reinitialize the log statistics.
-  logCount = 0;
-  logSize = 0;
-  errorLogCount = 0;
-  errorLogSize = 0;
-  prohibitedCount = 0;
-  visitTimeoutCount = 0;
-  visitRejectionCount = 0;
-  // Add the start time to the report.
-  const startTime = new Date();
-  report.startTime = startTime.toISOString().slice(0, 19);
-  // Add initialized properties to the report.
-  report.presses = 0;
-  report.amountRead = 0;
-  report.testTimes = [];
-  // Perform the specified acts.
-  await doActs(report, 0, null);
-  // Add the log statistics to the report.
-  report.logCount = logCount;
-  report.logSize = logSize;
-  report.errorLogCount = errorLogCount;
-  report.errorLogSize = errorLogSize;
-  report.prohibitedCount = prohibitedCount;
-  report.visitTimeoutCount = visitTimeoutCount;
-  report.visitRejectionCount = visitRejectionCount;
-  report.visitLatency = visitLatency;
-  // Add the end time and duration to the report.
-  const endTime = new Date();
-  report.endTime = endTime.toISOString().slice(0, 19);
-  report.elapsedSeconds =  Math.floor((endTime - startTime) / 1000);
-  // Add an end time to the log.
-  report.log.push({
-    event: 'endTime',
-    value: ((new Date()).toISOString().slice(0, 19))
-  });
-};
 // Injects launch and url acts into a report where necessary to undo DOM changes.
 const injectLaunches = acts => {
   let injectMore = true;
@@ -1552,17 +1503,6 @@ const injectLaunches = acts => {
 exports.doJob = async report => {
   // If the report object is valid:
   if(isValidReport(report)) {
-    // Add a start time to the log.
-    report.log.push(
-      {
-        event: 'startTime',
-        value: ((new Date()).toISOString().slice(0, 19))
-      }
-    );
-    // Add a time stamp to the report.
-    report.timeStamp = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
-    // Add an ID to the report.
-    report.id = `${report.timeStamp}-${report.script.id}`;
     // Add the script commands to the report as its initial acts.
     report.acts = JSON.parse(JSON.stringify(report.script.commands));
     /*
@@ -1572,10 +1512,31 @@ exports.doJob = async report => {
     if (urlInject === 'yes') {
       injectLaunches(report.acts);
     }
-    // Perform the acts, asynchronously adding to the log and report.
-    await doScript(report);
-  }
-  else {
-    console.log('ERROR: options missing or invalid');
+    // Add initialized job data to the report.
+    const startTime = new Date();
+    report.jobData = {
+      startTime: nowString(),
+      endTime: '',
+      elapsedSeconds: 0,
+      visitLatency: 0,
+      logCount: 0,
+      logSize: 0,
+      errorLogCount: 0,
+      errorLogSize: 0,
+      prohibitedCount: 0,
+      visitTimeoutCount: 0,
+      visitRejectionCount: 0,
+      aborted: false,
+      abortedAct: null,
+      presses: 0,
+      amountRead: 0,
+      testTimes: []
+    };
+    // Recursively perform the specified acts.
+    await doActs(report, 0, null);
+    // Add the end time and duration to the report.
+    const endTime = new Date();
+    report.jobData.endTime = nowString();
+    report.jobData.elapsedSeconds =  Math.floor((endTime - startTime) / 1000);
   }
 };

package/watch.js

@@ -1,11 +1,6 @@
 /*
   watch.js
-  Watches for a script and runs it.
-  Arguments:
-    0. Watch type: 'dir' or 'net'.
-    1. How long to watch: 'once' or 'forever'.
-    2. How often to check in seconds.
-  Usage example: node watch dir once 15
+  Module for watching for a script and running it when found.
 */
 
 // ########## IMPORTS
@@ -19,15 +14,10 @@ const {doJob} = require('./run');
 
 // ########## CONSTANTS
 
-const watchType = process.argv[2];
-const watchForever = process.argv[3] === 'forever';
-const interval = Number.parseInt(process.argv[4]);
-let client;
-if (watchType === 'net') {
-  client = require(process.env.PROTOCOL || 'https');
-}
+const protocol = process.env.PROTOCOL || 'https';
+const client = require(protocol);
 const jobURL = process.env.JOB_URL;
-const worker = process.env.WORKER;
+const agent = process.env.AGENT;
 const watchDir = process.env.WATCHDIR;
 const doneDir = process.env.DONEDIR;
 const reportURL = process.env.REPORT_URL;
@@ -64,7 +54,7 @@ const checkDirJob = async () => {
 // Checks for a network job.
 const checkNetJob = async () => {
   const script = await new Promise(resolve => {
-    const wholeURL = `${process.env.PROTOCOL}://${jobURL}?worker=${worker}`;
+    const wholeURL = `${protocol}://${jobURL}?agent=${agent}`;
     const request = client.request(wholeURL, response => {
       const chunks = [];
       response.on('data', chunk => {
@@ -96,7 +86,7 @@ const writeDirReport = async report => {
   if (scriptID) {
     try {
       const reportJSON = JSON.stringify(report, null, 2);
-      const reportName = `${report.timeStamp}-${scriptID}.json`;
+      const reportName = `${report.script.timeStamp}-${scriptID}.json`;
       await fs.writeFile(`${reportDir}/${reportName}`, reportJSON);
       console.log(`Report ${reportName} saved`);
       return true;
@@ -110,7 +100,7 @@ const writeDirReport = async report => {
 // Submits a network report.
 const writeNetReport = async report => {
   const ack = await new Promise(resolve => {
-    const wholeURL = `${process.env.PROTOCOL}://${reportURL}?worker=${worker}`;
+    const wholeURL = `${process.env.PROTOCOL}://${reportURL}?agent=${agent}`;
     const request = client.request(wholeURL, {method: 'POST'}, response => {
       const chunks = [];
       response.on('data', chunk => {
@@ -131,14 +121,14 @@ const writeNetReport = async report => {
     });
     request.write(JSON.stringify(report, null, 2));
     request.end();
-    console.log(`Report ${report.timeStamp}-${report.script.id} submitted`);
+    console.log(`Report ${report.script.id} submitted`);
   });
   return ack;
 };
 // Archives a job.
 const archiveJob = async script => {
   const scriptJSON = JSON.stringify(script, null, 2);
-  await fs.writeFile(`${doneDir}/${script.timeStamp}-${script.id}.json`, scriptJSON);
+  await fs.writeFile(`${doneDir}/${script.id}.json`, scriptJSON);
   await fs.rm(`${watchDir}/${script.id}.json`);
 };
 // Waits.
@@ -149,25 +139,27 @@ const wait = ms => {
     }, ms);
   });
 };
-// Runs a script, time-stamps it, and returns a report.
-const runJob = async script => {
+// Runs a job and returns a report.
+exports.runJob = async (script, isDirWatch) => {
   const {id} = script;
   if (id) {
     try {
-      // Identify the start time and a time stamp.
-      const timeStamp = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
-      script.timeStamp = timeStamp;
       // Initialize a report.
       const report = {
         log: [],
         script,
         acts: []
       };
+      // Run the job, adding to the report.
       await doJob(report);
-      if (watchType === 'dir') {
+      // If a directory was watched:
+      if (isDirWatch) {
+        // Save the report.
         return await writeDirReport(report);
       }
+      // Otherwise, i.e. if the network was watched:
       else {
+        // Send the report to the server.
         const ack = await writeNetReport(report);
         if (ack.error) {
           console.log(JSON.stringify(ack, null, 2));
@@ -193,9 +185,10 @@ const runJob = async script => {
   }
 };
 // Checks for a job, performs it, and submits a report, once or repeatedly.
-const cycle = async forever => {
+exports.cycle = async (isDirWatch, isForever, interval) => {
   const intervalMS = 1000 * Number.parseInt(interval);
   let statusOK = true;
+  // Prevent a wait before the first iteration.
   let empty = false;
   console.log(`Watching started with intervals of ${interval} seconds when idle`);
   while (statusOK) {
@@ -204,32 +197,29 @@ const cycle = async forever => {
     }
     // Check for a job.
     let script;
-    if (watchType === 'dir') {
+    if (isDirWatch) {
       script = await checkDirJob();
     }
-    else if (watchType === 'net') {
-      script = await checkNetJob();
-    }
     else {
-      script = {};
-      console.log('ERROR: invalid WATCH_TYPE environment variable');
-      statusOK = false;
+      script = await checkNetJob();
     }
     // If there was one:
     if (script.id) {
-      // Run it, add a timestamp to it, and save a report.
+      // Run it and save a report.
       console.log(`Running script ${script.id}`);
-      statusOK = await runJob(script);
-      console.log(`Job ${script.id} finished with time stamp ${script.timeStamp}`);
+      statusOK = await exports.runJob(script, isDirWatch);
+      console.log(`Job ${script.id} finished`);
       if (statusOK) {
-        // If the script was in a directory:
-        if (watchType === 'dir') {
+        // If a directory was watched:
+        if (isDirWatch) {
           // Archive the script.
           await archiveJob(script);
-          console.log(`Script ${script.id}.json archived as ${script.timeStamp}-${script.id}.json`);
+          console.log(`Script ${script.id} archived`);
         }
         // If watching was specified for only 1 job, stop.
-        statusOK = forever;
+        statusOK = isForever;
+        // Prevent a wait before the next iteration.
+        empty = false;
       }
     }
     else {
@@ -238,8 +228,3 @@ const cycle = async forever => {
   }
   console.log('Watching ended');
 };
-
-// ########## OPERATION
-
-// Start watching, as specified, either forever or until 1 job is run.
-cycle(watchForever);

package/runScript.js

@@ -1,48 +0,0 @@
-/*
-  runScript.js
-  Runs a script and writes a report file.
-*/
-
-// ########## IMPORTS
-
-const {doJob} = require('./run');
-
-// ########## FUNCTIONS
-
-// Runs a script and returns the report.
-const runScript = async (id, scriptJSON) => {
-  const report = {
-    id,
-    log: [],
-    script: JSON.parse(scriptJSON),
-    acts: []
-  };
-  let reportJSON = JSON.stringify(report, null, 2);
-  await doJob(report);
-  report.acts.forEach(act => {
-    try {
-      JSON.stringify(act);
-    }
-    catch (error) {
-      console.log(`ERROR: act of type ${act.type} malformatted`);
-      act = {
-        type: act.type || 'ERROR',
-        which: act.which || 'N/A',
-        prevented: true,
-        error: error.message
-      };
-      console.log(`act changed to:\n${JSON.stringify(act, null, 2)}`);
-    }
-  });
-  try {
-    reportJSON = JSON.stringify(report, null, 2);
-    return reportJSON;
-  }
-  catch(error) {
-    console.log(`ERROR: report for host ${id} not JSON (${error.message})`);
-    return '';
-  }
-};
-
-// ########## OPERATION
-runScript(... process.argv.slice(2));