testaro 4.1.2 → 4.2.0

package/validation/executors/watchNet.js

@@ -0,0 +1,106 @@
+// watchDir.js
+// Validator for network watching.
+
+const fs = require('fs/promises');
+process.env.WATCH_TYPE = 'net';
+process.env.INTERVAL = 5;
+process.env.WATCH_FOREVER = false;
+process.env.PROTOCOL = 'http';
+process.env.JOB_URL = 'localhost:3007/job';
+process.env.REPORT_URL = 'localhost:3007/report';
+process.env.AUTH_CODE = 'testarauth';
+process.env.PROTOCOL = 'http';
+const http = require('http');
+// Start a timer.
+const startTime = Date.now();
+// Initialize the state.
+let jobGiven = false;
+// Start checking for jobs every 5 seconds in 5 seconds.
+setTimeout(() => {
+  require('../../watch');
+}, 5000);
+let server;
+// Handles Testaro requests to the server.
+const requestHandler = (request, response) => {
+  const {method} = request;
+  const bodyParts = [];
+  request.on('error', err => {
+    console.error(err);
+  })
+  .on('data', chunk => {
+    bodyParts.push(chunk);
+  })
+  .on('end', async () => {
+    // Remove any trailing slash from the URL.
+    const requestURL = request.url.replace(/\/$/, '');
+    // If the request method is GET:
+    if (method === 'GET') {
+      // If a job is validly requested:
+      console.log('Server got a job request from Testaro');
+      if (requestURL === '/job?authCode=testarauth') {
+        // If at least 7 seconds has elapsed since timing started:
+        if (Date.now() > startTime + 7000) {
+          // Respond with a job.
+          const jobJSON = await fs.readFile(`${__dirname}/../protoJobs/val1.json`);
+          await response.end(jobJSON);
+          console.log('Server sent job val1 to Testaro');
+          jobGiven = true;
+        }
+        // Otherwise, i.e. if timing started less than 7 seconds ago:
+        else {
+          // Send an empty-object response.
+          await response.end('{}');
+        }
+      }
+      else {
+        const error = {
+          error: 'ERROR: Job request invalid'
+        };
+        const errorJSON = JSON.stringify(error);
+        await response.end(errorJSON);
+      }
+    }
+    // Otherwise, if the request method is POST:
+    else if (method === 'POST') {
+      console.log('Server got report from Testaro');
+      const ack = {};
+      // If a report is validly submitted:
+      if (requestURL === '/report?authCode=testarauth') {
+        // If a job was earlier given to Testaro:
+        if (jobGiven) {
+          // Respond, reporting success or failure.
+          try {
+            const bodyJSON = bodyParts.join('');
+            const body = JSON.parse(bodyJSON);
+            if (body.jobID && body.script && body.acts) {
+              ack.result = 'Success: Valid report submitted';
+            }
+            else {
+              ack.result = 'Failure: Report invalid';
+            }
+          }
+          catch(error) {
+            ack.result = `ERROR: ${error.message}`;
+          }
+        }
+      }
+      else {
+        ack.result = 'ERROR: Report submission invalid';
+      }
+      const ackJSON = JSON.stringify(ack);
+      response.end(ackJSON);
+      console.log(`Server responded: ${ack.result}`);
+      // This ends the validation, so stop the server.
+      server.close();
+      console.log('Server closed');
+    }
+  });
+};
+// Create a server.
+server = http.createServer({}, requestHandler);
+// Start a server listening for Testaro requests.
+server.listen(3007, () => {
+  console.log('Job and report server listening on port 3007');
+});
+// Start checking for jobs every 5 seconds.
+require('../../watch');

package/validation/jobs/README.md

@@ -0,0 +1,3 @@
+# jobs
+
+Directory watched by executor `watchDir`.

package/validation/protoJobs/README.md

@@ -0,0 +1,3 @@
+# protoJobs
+
+Jobs that can be copied into `jobs` for `watchDir`.

package/validation/protoJobs/val1.json

@@ -0,0 +1,25 @@
+{
+  "jobID": "val1",
+  "script": {
+    "id": "simple",
+    "what": "Test example.com with bulk",
+    "strict": true,
+    "commands": [
+      {
+        "type": "launch",
+        "which": "chromium",
+        "what": "Chromium browser"
+      },
+      {
+        "type": "url",
+        "which": "https://example.com/",
+        "what": "page with a few accessibility defects"
+      },
+      {
+        "type": "test",
+        "which": "bulk",
+        "what": "bulk"
+      }
+    ]
+  }
+}

package/validation/protoJobs/val2.json

@@ -0,0 +1,41 @@
+{
+  "jobID": "val2",
+  "script": {
+    "id": "simple",
+    "what": "Test example.com with bulk",
+    "strict": true,
+    "commands": [
+      {
+        "type": "launch",
+        "which": "chromium",
+        "what": "Chromium browser"
+      },
+      {
+        "type": "url",
+        "which": "https://example.com/",
+        "what": "page with a few accessibility defects"
+      },
+      {
+        "type": "test",
+        "which": "bulk",
+        "what": "bulk"
+      }
+    ]
+  },
+  "batch": {
+    "id": "weborgs",
+    "what": "Web organizations",
+    "hosts": [
+      {
+        "id": "mozilla",
+        "which": "https://www.mozilla.org/en-US/",
+        "what": "Mozilla"
+      },
+      {
+        "id": "w3c",
+        "which": "https://www.w3.org/",
+        "what": "W3C"
+      }
+    ]
+  }
+}

package/watch.js

@@ -0,0 +1,281 @@
+/*
+  watch.js
+  Watches for jobs and runs them.
+*/
+
+// ########## IMPORTS
+
+// Module to keep secrets local.
+// require('dotenv').config({override: true});
+require('dotenv').config();
+// Module to read and write files.
+const fs = require('fs/promises');
+// Module to perform tests.
+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 watchType = process.env.WATCH_TYPE;
+let client;
+if (watchType === 'net') {
+  client = require(process.env.PROTOCOL || 'https');
+}
+const jobURL = process.env.JOB_URL;
+const authCode = process.env.AUTH_CODE;
+const jobDir = process.env.JOBDIR;
+const exJobDir = process.env.EXJOBDIR;
+const reportURL = process.env.REPORT_URL;
+const reportDir = process.env.REPORTDIR;
+const interval = process.env.INTERVAL;
+// Values of process.env properties are coerced to strings.
+const watchForever = process.env.WATCH_FOREVER == 'true';
+
+// ########## FUNCTIONS
+
+// Checks for a directory job.
+const checkDirJob = async () => {
+  const jobDirFileNames = await fs.readdir(jobDir);
+  const jobFileNames = jobDirFileNames.filter(fileName => fileName.endsWith('.json'));
+  if (jobFileNames.length) {
+    const firstJobID = jobFileNames[0].slice(0, -5);
+    const jobJSON = await fs.readFile(`${jobDir}/${jobFileNames[0]}`, 'utf8');
+    try {
+      const job = JSON.parse(jobJSON, null, 2);
+      job.jobID = firstJobID;
+      return job;
+    }
+    catch(error) {
+      return {
+        error: 'ERROR: Job was not JSON',
+        message: error.message
+      };
+    }
+  }
+  else {
+    return {};
+  }
+};
+// Checks for a network job.
+const checkNetJob = async () => {
+  const job = await new Promise(resolve => {
+    const wholeURL = `${process.env.PROTOCOL}://${jobURL}?authCode=${authCode}`;
+    const request = client.request(wholeURL, response => {
+      const chunks = [];
+      response.on('data', chunk => {
+        chunks.push(chunk);
+      });
+      response.on('end', () => {
+        try {
+          const jobJSON = chunks.join('');
+          const job = JSON.parse(jobJSON);
+          // If a qualifying job was received:
+          if (job.jobID) {
+            // Return it.
+            resolve(job);
+          }
+          // Otherwise, i.e. if there was no qualifying job:
+          else {
+            // Return this.
+            resolve({});
+          }
+        }
+        catch(error) {
+          resolve({
+            error: 'ERROR: Response was not JSON',
+            message: error.message,
+            status: response.statusCode
+          });
+        }
+      });
+    });
+    request.end();
+  });
+  return job;
+};
+// Writes a directory report.
+const writeDirReport = async report => {
+  const {id, jobID} = report;
+  if (id && jobID) {
+    const reportJSON = JSON.stringify(report, null, 2);
+    try {
+      await fs.writeFile(`${reportDir}/${id}.json`, reportJSON);
+      console.log(`Report ${id}.json saved`);
+      return true;
+    }
+    catch(error) {
+      console.log(`ERROR: Failed to write report ${id} for job ${jobID}`);
+      return false;
+    }
+  }
+};
+// Submits a network report.
+const writeNetReport = async report => {
+  const ack = await new Promise(resolve => {
+    const wholeURL = `${process.env.PROTOCOL}://${reportURL}?authCode=${authCode}`;
+    const request = client.request(wholeURL, {method: 'POST'}, response => {
+      const chunks = [];
+      response.on('data', chunk => {
+        chunks.push(chunk);
+      });
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(chunks.join('')));
+        }
+        catch(error) {
+          resolve({
+            error: 'ERROR: Response was not JSON',
+            message: error.message,
+            status: response.statusCode
+          });
+        }
+      });
+    });
+    request.write(JSON.stringify(report, null, 2));
+    request.end();
+    console.log(`Report with ID ${report.id} submitted`);
+  });
+  return ack;
+};
+// Archives a job.
+const exifyJob = async (job) => {
+  const jobJSON = JSON.stringify(job, null, 2);
+  await fs.writeFile(`${exJobDir}/${job.timeStamp}.json`, jobJSON);
+  await fs.rm(`${jobDir}/${job.jobID}.json`);
+};
+// Waits.
+const wait = ms => {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve('');
+    }, ms);
+  });
+};
+// Runs one script and writes or sends a report.
+const runHost = async (jobID, timeStamp, id, script) => {
+  const report = {
+    jobID,
+    timeStamp,
+    id,
+    log: [],
+    script,
+    acts: []
+  };
+  await handleRequest(report);
+  if (watchType === 'dir') {
+    return await writeDirReport(report);
+  }
+  else {
+    const ack = await writeNetReport(report);
+    if (ack.error) {
+      console.log(JSON.stringify(ack, null, 2));
+      return false;
+    }
+    else {
+      return true;
+    }
+  }
+};
+// Runs a job and returns a report file for the script or each host.
+const runJob = async job => {
+  const {jobID, script, batch} = job;
+  if (jobID) {
+    if (script) {
+      try {
+        // Identify the start time and a time stamp.
+        const timeStamp = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
+        job.timeStamp = timeStamp;
+        // If there is a batch:
+        if (batch) {
+          // Convert the script to a set of host scripts.
+          const specs = batchify(script, batch, timeStamp);
+          // For each host script:
+          let success = true;
+          while (specs.length && success) {
+            // Run it and write or submit a report with a host-suffixed time-stamp ID.
+            const spec = specs.shift();
+            const {id} = spec;
+            const hostScript = spec.script;
+            success = await runHost(jobID, timeStamp, id, hostScript);
+          }
+          return success;
+        }
+        // Otherwise, i.e. if there is no batch:
+        else {
+          // Run the script and submit a report with a timestamp ID.
+          return await runHost(jobID, timeStamp, timeStamp, script);
+        }
+      }
+      catch(error) {
+        console.log(`ERROR: ${error.message}\n${error.stack}`);
+        return {
+          error: `ERROR: ${error.message}\n${error.stack}`
+        };
+      }
+    }
+    else {
+      console.log('ERROR: no script specified');
+      return {
+        error: 'ERROR: no script specified'
+      };
+    }
+  }
+  else {
+    console.log('ERROR: no job ID property in job');
+    return {
+      error: 'ERROR: no job ID property in job'
+    };
+  }
+};
+// Repeatedly checks for jobs, runs them, and submits reports.
+const cycle = async forever => {
+  const intervalMS = Number.parseInt(interval);
+  let statusOK = true;
+  let empty = false;
+  console.log(`Watching started with intervals of ${interval} seconds when idle`);
+  while (statusOK) {
+    if (empty) {
+      await wait(1000 * intervalMS);
+    }
+    // Check for a job.
+    let job;
+    if (watchType === 'dir') {
+      job = await checkDirJob();
+    }
+    else if (watchType === 'net') {
+      job = await checkNetJob();
+    }
+    else {
+      job = {};
+      console.log('ERROR: invalid WATCH_TYPE environment variable');
+      statusOK = false;
+    }
+    // If there was one:
+    if (job.jobID) {
+      // Run it.
+      console.log(`Running job ${job.jobID}`);
+      statusOK = await runJob(job);
+      console.log(`Job ${job.jobID} finished with time stamp ${job.timeStamp}`);
+      if (statusOK) {
+        // If the job was a file:
+        if (watchType === 'dir') {
+          // Archive it.
+          await exifyJob(job);
+          console.log(`Job archived as ${job.timeStamp}.json`);
+        }
+        // If watching was specified for only 1 job, stop.
+        statusOK = forever;
+      }
+    }
+    else {
+      empty = true;
+    }
+  }
+  console.log('Watching ended');
+};
+
+// ########## OPERATION
+
+// Start watching, as specified, either forever or until 1 job is run.
+cycle(watchForever);