testaro 2.3.11 → 4.0.0

package/index.js

@@ -3,6 +3,8 @@
   testaro main script.
 */
 // ########## IMPORTS
+// Module to keep secrets.
+require('dotenv').config();
 // Requirements for commands.
 const {commands} = require('./commands');
 // ########## CONSTANTS
@@ -40,6 +42,7 @@ const tests = {
   role: 'roles',
   styleDiff: 'style inconsistencies',
   tabNav: 'keyboard navigation between tab elements',
+  tenon: 'Tenon',
   wave: 'WAVE',
   zIndex: 'z indexes'
 };
@@ -55,6 +58,11 @@ const browserTypeNames = {
 };
 // Items that may be waited for.
 const waitables = ['url', 'title', 'body'];
+// Tenon data.
+const tenonData = {
+  accessToken: '',
+  requestIDs: {}
+};
 // ########## VARIABLES
 // Facts about the current session.
 let logCount = 0;
@@ -194,38 +202,18 @@ const isValidScript = script => {
     && isURL(commands[1].which)
     && commands.every(command => isValidCommand(command));
 };
-// Validates a batch.
-const isValidBatch = batch => {
-  // If the batch exists:
-  if (batch) {
-    // Get its data.
-    const {what, hosts} = batch;
-    // Return whether the batch is valid:
-    return what
-      && hosts
-      && typeof what === 'string'
-      && Array.isArray(hosts)
-      && hosts.every(host => host.which && host.what && isURL(host.which));
-  }
-  // Otherwise, i.e. if the batch does not exist:
-  else {
-    // Return that it is valid, because it is optional.
-    return true;
-  }
-};
 // Validates an initialized reports array.
-const isValidReports = reports => Array.isArray(reports) && ! reports.length;
+const isValidActs = acts => Array.isArray(acts) && ! acts.length;
 // Validates an initialized log array.
 const isValidLog = log => Array.isArray(log) && ! log.length;
-// Validates an options object.
-const isValidOptions = async options => {
-  if (options) {
-    const {id, script, batch, log, reports} = options;
+// Validates a report object.
+const isValidReport = async report => {
+  if (report) {
+    const {id, script, log, acts} = report;
     return id
     && isValidScript(script)
-    && isValidBatch(batch)
     && isValidLog(log)
-    && isValidReports(reports);
+    && isValidActs(acts);
   }
   else {
     return false;
@@ -379,7 +367,7 @@ const textOf = async (page, element) => {
 const matchElement = async (page, selector, matchText, index = 0) => {
   // If the page still exists:
   if (page) {
-    // Wait 3 seconds until the body contains any text to be matched.
+    // Wait 2 seconds until the body contains any text to be matched.
     const slimText = debloat(matchText);
     const bodyText = await page.textContent('body');
     const slimBody = debloat(bodyText);
@@ -569,7 +557,7 @@ const waitError = (page, act, error, what) => {
   act.result.error = `ERROR waiting for ${what}`;
   return false;
 };
-// Recursively performs the commands in a report.
+// Recursively performs the acts in a report.
 const doActs = async (report, actIndex, page) => {
   const {acts} = report;
   // If any more commands are to be performed:
@@ -726,157 +714,125 @@ const doActs = async (report, actIndex, page) => {
               await require('./procs/test/allVis').allVis(page);
               act.result = 'All elements visible.';
             }
-            // Otherwise, if it is a repetitive keyboard navigation:
-            else if (act.type === 'presses') {
-              const {navKey, what, which, withItems} = act;
-              const matchTexts = which ? which.map(text => debloat(text)) : [];
-              // Initialize the loop variables.
-              let status = 'more';
-              let presses = 0;
-              let amountRead = 0;
-              let items = [];
-              let matchedText;
-              // As long as a matching element has not been reached:
-              while (status === 'more') {
-                // Press the Escape key to dismiss any modal dialog.
-                await page.keyboard.press('Escape');
-                // Press the specified navigation key.
-                await page.keyboard.press(navKey);
-                presses++;
-                // Identify the newly current element or a failure.
-                const currentJSHandle = await page.evaluateHandle(actCount => {
-                  // Initialize it as the focused element.
-                  let currentElement = document.activeElement;
-                  // If it exists in the page:
-                  if (currentElement && currentElement.tagName !== 'BODY') {
-                    // Change it, if necessary, to its active descendant.
-                    if (currentElement.hasAttribute('aria-activedescendant')) {
-                      currentElement = document.getElementById(
-                        currentElement.getAttribute('aria-activedescendant')
-                      );
-                    }
-                    // Or change it, if necessary, to its selected option.
-                    else if (currentElement.tagName === 'SELECT') {
-                      const currentIndex = Math.max(0, currentElement.selectedIndex);
-                      const options = currentElement.querySelectorAll('option');
-                      currentElement = options[currentIndex];
-                    }
-                    // Or change it, if necessary, to its active shadow-DOM element.
-                    else if (currentElement.shadowRoot) {
-                      currentElement = currentElement.shadowRoot.activeElement;
-                    }
-                    // If there is a current element:
-                    if (currentElement) {
-                      // If it was already reached within this command performance:
-                      if (currentElement.dataset.pressesReached === actCount.toString(10)) {
-                        // Report the error.
-                        console.log(`ERROR: ${currentElement.tagName} element reached again`);
-                        status = 'ERROR';
-                        return 'ERROR: locallyExhausted';
-                      }
-                      // Otherwise, i.e. if it is newly reached within this act:
-                      else {
-                        // Mark and return it.
-                        currentElement.dataset.pressesReached = actCount;
-                        return currentElement;
-                      }
-                    }
-                    // Otherwise, i.e. if there is no current element:
-                    else {
-                      // Report the error.
-                      status = 'ERROR';
-                      return 'noActiveElement';
-                    }
-                  }
-                  // Otherwise, i.e. if there is no focus in the page:
-                  else {
-                    // Report the error.
-                    status = 'ERROR';
-                    return 'ERROR: globallyExhausted';
-                  }
-                }, actCount);
-                // If the current element exists:
-                const currentElement = currentJSHandle.asElement();
-                if (currentElement) {
-                  // Update the data.
-                  const tagNameJSHandle = await currentElement.getProperty('tagName');
-                  const tagName = await tagNameJSHandle.jsonValue();
-                  const text = await textOf(page, currentElement);
-                  // If the text of the current element was found:
-                  if (text !== null) {
-                    const textLength = text.length;
-                    // If it is non-empty and there are texts to match:
-                    if (matchTexts.length && textLength) {
-                      // Identify the matching text.
-                      matchedText = matchTexts.find(matchText => text.includes(matchText));
-                    }
-                    // Update the item data if required.
-                    if (withItems) {
-                      const itemData = {
-                        tagName,
-                        text,
-                        textLength
-                      };
-                      if (matchedText) {
-                        itemData.matchedText = matchedText;
+            // Otherwise, if the act is a tenon request:
+            else if (act.type === 'tenonRequest') {
+              const {id, withNewContent} = act;
+              const https = require('https');
+              // If a Tenon access token has not yet been obtained:
+              if (! tenonData.accessToken) {
+                // Authenticate with the Tenon API.
+                const authData = await new Promise(resolve => {
+                  const request = https.request(
+                    {
+                      host: 'tenon.io',
+                      path: '/api/v2/auth',
+                      port: 443,
+                      protocol: 'https:',
+                      method: 'POST',
+                      headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
                       }
-                      items.push(itemData);
-                    }
-                    amountRead += textLength;
-                    // If there is no text-match failure:
-                    if (matchedText || ! matchTexts.length) {
-                      // If the element has any specified tag name:
-                      if (! what || tagName === what) {
-                        // Change the status.
-                        status = 'done';
-                        // Perform the action.
-                        const inputText = act.text;
-                        if (inputText) {
-                          await page.keyboard.type(inputText);
-                          presses += inputText.length;
+                    },
+                    response => {
+                      let responseData = '';
+                      response.on('data', chunk => {
+                        responseData += chunk;
+                      });
+                      response.on('end', () => {
+                        try {
+                          const responseJSON = JSON.parse(responseData);
+                          return resolve(responseJSON);
                         }
-                        if (act.action) {
-                          presses++;
-                          await page.keyboard.press(act.action);
-                          await page.waitForLoadState();
+                        catch(error) {
+                          return resolve({
+                            error: 'Tenon did not return JSON authentication data.',
+                            responseData
+                          });
                         }
-                      }
+                      });
                     }
-                  }
-                  else {
-                    status = 'ERROR';
-                  }
+                  );
+                  const tenonUser = process.env.TESTARO_TENON_USER;
+                  const tenonPassword = process.env.TESTARO_TENON_PASSWORD;
+                  const postData = JSON.stringify({
+                    username: tenonUser,
+                    password: tenonPassword
+                  });
+                  request.write(postData);
+                  request.end();
+                });
+                // If the authentication succeeded:
+                if (authData.access_token) {
+                  // Record the access token.
+                  tenonData.accessToken = authData.access_token;
                 }
-                // Otherwise, i.e. if there was a failure:
+                // Otherwise, i.e. if the authentication failed:
                 else {
-                  // Update the status.
-                  status = await currentJSHandle.jsonValue();
+                  console.log('ERROR: tenon authentication failed');
                 }
               }
-              // Add the result to the act.
-              act.result = {
-                status,
-                totals: {
-                  presses,
-                  amountRead
+              // If a Tenon access token exists:
+              if (tenonData.accessToken) {
+                // Request a Tenon test of the page and get a response ID.
+                const option = {};
+                // If Tenon is to be given the URL and not the content of the page:
+                if (withNewContent) {
+                  // Specify this.
+                  option.url = page.url();
                 }
-              };
-              if (status === 'done' && matchedText) {
-                act.result.matchedText = matchedText;
-              }
-              if (withItems) {
-                act.result.items = items;
+                // Otherwise, i.e. if Tenon is to be given the page content:
+                else {
+                  // Specify this.
+                  option.src = await page.content();
+                }
+                // Request a Tenon test and get a response ID.
+                const responseID = await new Promise(resolve => {
+                  const request = https.request(
+                    {
+                      host: 'tenon.io',
+                      path: '/api/v2/',
+                      port: 443,
+                      protocol: 'https:',
+                      method: 'POST',
+                      headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache',
+                        Authorization: `Bearer ${tenonData.accessToken}`
+                      }
+                    },
+                    response => {
+                      let resultJSON = '';
+                      response.on('data', chunk => {
+                        resultJSON += chunk;
+                      });
+                      // When the data arrive, return them as an object.
+                      response.on('end', () => {
+                        try {
+                          const result = JSON.parse(resultJSON);
+                          resolve(result.data.responseID || '');
+                        }
+                        catch (error) {
+                          console.log('ERROR: Tenon did not return JSON.');
+                          resolve('');
+                        }
+                      });
+                    }
+                  );
+                  const postData = JSON.stringify(option);
+                  request.write(postData);
+                  request.end();
+                });
+                // Record the response ID.
+                tenonData.requestIDs[id] = responseID || '';
               }
-              // Add the totals to the report.
-              report.presses += presses;
-              report.amountRead += amountRead;
             }
             // Otherwise, if the act is a test:
             else if (act.type === 'test') {
               // Add a description of the test to the act.
               act.what = tests[act.which];
               // Initialize the arguments.
-              const args = [page];
+              const args = [act.which === 'tenon' ? tenonData : page];
               // Identify the additional validator of the test.
               const testValidator = commands.tests[act.which];
               // If it exists:
@@ -1009,7 +965,7 @@ const doActs = async (report, actIndex, page) => {
                 // Otherwise, if it is entering text on the element:
                 else if (act.type === 'text') {
                   // If the text contains a placeholder for an environment variable:
-                  let {what} = act; 
+                  let {what} = act;
                   if (/__[A-Z]+__/.test(what)) {
                     // Replace it.
                     const envKey = /__([A-Z]+)__/.exec(what)[1];
@@ -1045,6 +1001,151 @@ const doActs = async (report, actIndex, page) => {
               const qualifier = act.again ? `${1 + act.again} times` : 'once';
               act.result = `pressed ${qualifier}`;
             }
+            // Otherwise, if it is a repetitive keyboard navigation:
+            else if (act.type === 'presses') {
+              const {navKey, what, which, withItems} = act;
+              const matchTexts = which ? which.map(text => debloat(text)) : [];
+              // Initialize the loop variables.
+              let status = 'more';
+              let presses = 0;
+              let amountRead = 0;
+              let items = [];
+              let matchedText;
+              // As long as a matching element has not been reached:
+              while (status === 'more') {
+                // Press the Escape key to dismiss any modal dialog.
+                await page.keyboard.press('Escape');
+                // Press the specified navigation key.
+                await page.keyboard.press(navKey);
+                presses++;
+                // Identify the newly current element or a failure.
+                const currentJSHandle = await page.evaluateHandle(actCount => {
+                  // Initialize it as the focused element.
+                  let currentElement = document.activeElement;
+                  // If it exists in the page:
+                  if (currentElement && currentElement.tagName !== 'BODY') {
+                    // Change it, if necessary, to its active descendant.
+                    if (currentElement.hasAttribute('aria-activedescendant')) {
+                      currentElement = document.getElementById(
+                        currentElement.getAttribute('aria-activedescendant')
+                      );
+                    }
+                    // Or change it, if necessary, to its selected option.
+                    else if (currentElement.tagName === 'SELECT') {
+                      const currentIndex = Math.max(0, currentElement.selectedIndex);
+                      const options = currentElement.querySelectorAll('option');
+                      currentElement = options[currentIndex];
+                    }
+                    // Or change it, if necessary, to its active shadow-DOM element.
+                    else if (currentElement.shadowRoot) {
+                      currentElement = currentElement.shadowRoot.activeElement;
+                    }
+                    // If there is a current element:
+                    if (currentElement) {
+                      // If it was already reached within this command performance:
+                      if (currentElement.dataset.pressesReached === actCount.toString(10)) {
+                        // Report the error.
+                        console.log(`ERROR: ${currentElement.tagName} element reached again`);
+                        status = 'ERROR';
+                        return 'ERROR: locallyExhausted';
+                      }
+                      // Otherwise, i.e. if it is newly reached within this act:
+                      else {
+                        // Mark and return it.
+                        currentElement.dataset.pressesReached = actCount;
+                        return currentElement;
+                      }
+                    }
+                    // Otherwise, i.e. if there is no current element:
+                    else {
+                      // Report the error.
+                      status = 'ERROR';
+                      return 'noActiveElement';
+                    }
+                  }
+                  // Otherwise, i.e. if there is no focus in the page:
+                  else {
+                    // Report the error.
+                    status = 'ERROR';
+                    return 'ERROR: globallyExhausted';
+                  }
+                }, actCount);
+                // If the current element exists:
+                const currentElement = currentJSHandle.asElement();
+                if (currentElement) {
+                  // Update the data.
+                  const tagNameJSHandle = await currentElement.getProperty('tagName');
+                  const tagName = await tagNameJSHandle.jsonValue();
+                  const text = await textOf(page, currentElement);
+                  // If the text of the current element was found:
+                  if (text !== null) {
+                    const textLength = text.length;
+                    // If it is non-empty and there are texts to match:
+                    if (matchTexts.length && textLength) {
+                      // Identify the matching text.
+                      matchedText = matchTexts.find(matchText => text.includes(matchText));
+                    }
+                    // Update the item data if required.
+                    if (withItems) {
+                      const itemData = {
+                        tagName,
+                        text,
+                        textLength
+                      };
+                      if (matchedText) {
+                        itemData.matchedText = matchedText;
+                      }
+                      items.push(itemData);
+                    }
+                    amountRead += textLength;
+                    // If there is no text-match failure:
+                    if (matchedText || ! matchTexts.length) {
+                      // If the element has any specified tag name:
+                      if (! what || tagName === what) {
+                        // Change the status.
+                        status = 'done';
+                        // Perform the action.
+                        const inputText = act.text;
+                        if (inputText) {
+                          await page.keyboard.type(inputText);
+                          presses += inputText.length;
+                        }
+                        if (act.action) {
+                          presses++;
+                          await page.keyboard.press(act.action);
+                          await page.waitForLoadState();
+                        }
+                      }
+                    }
+                  }
+                  else {
+                    status = 'ERROR';
+                  }
+                }
+                // Otherwise, i.e. if there was a failure:
+                else {
+                  // Update the status.
+                  status = await currentJSHandle.jsonValue();
+                }
+              }
+              // Add the result to the act.
+              act.result = {
+                status,
+                totals: {
+                  presses,
+                  amountRead
+                }
+              };
+              if (status === 'done' && matchedText) {
+                act.result.matchedText = matchedText;
+              }
+              if (withItems) {
+                act.result.items = items;
+              }
+              // Add the totals to the report.
+              report.presses += presses;
+              report.amountRead += amountRead;
+            }
             // Otherwise, i.e. if the act type is unknown:
             else {
               // Add the error result to the act.
@@ -1079,7 +1180,7 @@ const doActs = async (report, actIndex, page) => {
   }
 };
 // Performs the commands in a script.
-const doScript = async (options, report) => {
+const doScript = async (report) => {
   // Reinitialize the log statistics.
   logCount = logSize = prohibitedCount = visitTimeoutCount = visitRejectionCount= 0;
   // Add the start time to the report.
@@ -1122,88 +1223,35 @@ const doScript = async (options, report) => {
   const endTime = new Date();
   report.endTime = endTime.toISOString().slice(0, 19);
   report.elapsedSeconds =  Math.floor((endTime - startTime) / 1000);
-  // Add the report to the reports array.
-  options.reports.push(report);
-};
-// Recursively performs commands on the hosts of a batch.
-const doBatch = async (options, reportTemplate, hostIndex = 0) => {
-  const {hosts} = options.batch;
-  const host = hosts[hostIndex];
-  // If the specified host exists:
-  if (host) {
-    // Create a report for it.
-    const hostReport = JSON.parse(JSON.stringify(reportTemplate));
-    // Copy the properties of the specified host to all url acts.
-    hostReport.acts.forEach(act => {
-      if (act.type === 'url') {
-        act.which = host.which;
-        act.what = host.what;
-      }
-    });
-    // Add the host’s ID to the host report.
-    hostReport.hostName = host.id;
-    // Add data from the template to the host report.
-    hostReport.orderName = options.id;
-    hostReport.id = `${options.id}-${host.id}`;
-    hostReport.orderUserName = options.userName;
-    hostReport.orderTime = options.orderTime;
-    hostReport.assignedBy = options.assignedBy;
-    hostReport.assignedTime = options.assignedTime;
-    hostReport.tester = options.tester;
-    hostReport.scriptName = options.scriptName;
-    hostReport.batchName = options.batchName;
-    hostReport.scriptIsValid = options.scriptIsValid;
-    hostReport.batchIsValid = options.batchIsValid;
-    hostReport.host = host;
-    // Perform the commands on the host and add a report to the options object.
-    await doScript(options, hostReport);
-    // Process the remaining hosts.
-    await doBatch(options, reportTemplate, hostIndex + 1);
-  }
-};
-// Performs a script, with or without a batch.
-const doScriptOrBatch = async (options, reportTemplate) => {
-  // If there is a batch:
-  if (options.batch) {
-    // Perform the script on all the hosts in the batch.
-    console.log('Starting batch');
-    await doBatch(options, reportTemplate);
-  }
-  // Otherwise, i.e. if there is no batch:
-  else {
-    // Perform the script.
-    console.log('Starting no-batch script');
-    await doScript(options, reportTemplate);
-  }
   // Add an end time to the log.
-  options.log.push({
+  report.log.push({
     event: 'endTime',
     value: ((new Date()).toISOString().slice(0, 19))
   });
 };
-// Injects url commands into a report where necessary to undo DOM changes.
-const injectURLCommands = commands => {
+// Injects url acts into a report where necessary to undo DOM changes.
+const injectURLActs = acts => {
   let injectMore = true;
   while (injectMore) {
-    const injectIndex = commands.findIndex((command, index) =>
-      index < commands.length - 1
-      && command.type === 'test'
-      && commands[index + 1].type === 'test'
-      && domChangers.has(command.which)
+    const injectIndex = acts.findIndex((act, index) =>
+      index < acts.length - 1
+      && act.type === 'test'
+      && acts[index + 1].type === 'test'
+      && domChangers.has(act.which)
     );
     if (injectIndex === -1) {
       injectMore = false;
     }
     else {
-      const lastURL = commands.reduce((url, command, index) => {
-        if (command.type === 'url' && index < injectIndex) {
-          return command.which;
+      const lastURL = acts.reduce((url, act, index) => {
+        if (act.type === 'url' && index < injectIndex) {
+          return act.which;
         }
         else {
           return url;
         }
       }, '');
-      commands.splice(injectIndex + 1, 0, {
+      acts.splice(injectIndex + 1, 0, {
         type: 'url',
         which: lastURL,
         what: 'URL'
@@ -1212,36 +1260,26 @@ const injectURLCommands = commands => {
   }
 };
 // Handles a request.
-exports.handleRequest = async options => {
-  // If the options object is valid:
-  if(isValidOptions(options)) {
-    // Add a start time and a timeStamp to the log.
-    options.log.push(
+exports.handleRequest = 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))
-      },
-      {
-        event: 'timeStamp',
-        value: Math.floor((Date.now() - Date.UTC(2022, 1)) / 500).toString(36)
       }
     );
-    // Add the batch size to the log if there is a batch.
-    if (options.batch) {
-      options.log.push({
-        event: 'batchSize',
-        value: options.batch.hosts.length
-      });
+    // Add an ID to the report if none exists yet.
+    if (! report.id) {
+      report.id = Math.floor((Date.now() - Date.UTC(2022, 1)) / 2000).toString(36);
     }
-    // Create a report template, containing a copy of the commands as its acts.
-    const reportTemplate = {
-      host: '',
-      acts: JSON.parse(JSON.stringify(options.script.commands))
-    };
+    // 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.
-    injectURLCommands(reportTemplate.acts);
-    // Perform the script, with or without a batch, asynchronously adding to the log and reports.
-    await doScriptOrBatch(options, reportTemplate);
+    injectURLActs(report.acts);
+    // Perform the script, asynchronously adding to the log and report.
+    await doScript(report);
   }
   else {
     console.log('ERROR: options missing or invalid');