testaro 3.0.1 → 4.1.0

package/{index.js → run.js}

@@ -3,8 +3,11 @@
   testaro main script.
 */
 // ########## IMPORTS
+// Module to keep secrets.
+require('dotenv').config();
 // Requirements for commands.
 const {commands} = require('./commands');
+const { handleRequest } = require('./job');
 // ########## CONSTANTS
 // Set DEBUG environment variable to 'true' to add debugging features.
 const debug = process.env.TESTARO_DEBUG === 'true';
@@ -40,6 +43,7 @@ const tests = {
   role: 'roles',
   styleDiff: 'style inconsistencies',
   tabNav: 'keyboard navigation between tab elements',
+  tenon: 'Tenon',
   wave: 'WAVE',
   zIndex: 'z indexes'
 };
@@ -55,6 +59,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;
@@ -359,7 +368,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);
@@ -605,17 +614,6 @@ const doActs = async (report, actIndex, page) => {
         // Identify its only page as current.
         page = browserContext.pages()[0];
       }
-      // Otherwise, if it is a score:
-      else if (act.type === 'score') {
-        // Compute and report the score.
-        try {
-          const {scorer} = require(`./procs/score/${act.which}`);
-          act.result = scorer(report.acts);
-        }
-        catch (error) {
-          act.error = `ERROR: ${error.message}\n${error.stack}`;
-        }
-      }
       // Otherwise, if a current page exists:
       else if (page) {
         // If the command is a url:
@@ -706,157 +704,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, 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'
                       }
-                    }
-                    // 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;
+                    },
+                    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:
@@ -1025,6 +991,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,25 +1190,6 @@ const doScript = async (report) => {
   report.prohibitedCount = prohibitedCount;
   report.visitTimeoutCount = visitTimeoutCount;
   report.visitRejectionCount = visitRejectionCount;
-  // If logs are to be scored, do so.
-  const scoreTables = report.acts.filter(act => act.type === 'score');
-  if (scoreTables.length) {
-    const scoreTable = scoreTables[0];
-    const {result} = scoreTable;
-    if (result) {
-      const {logWeights, scores} = result;
-      if (logWeights && scores) {
-        scores.log = Math.floor(
-          logWeights.count * logCount
-          + logWeights.size * logSize
-          + logWeights.prohibited * prohibitedCount
-          + logWeights.visitTimeout * visitTimeoutCount
-          + logWeights.visitRejection * visitRejectionCount
-        );
-        scores.total += scores.log;
-      }
-    }
-  }
   // Add the end time and duration to the report.
   const endTime = new Date();
   report.endTime = endTime.toISOString().slice(0, 19);
@@ -1164,3 +1256,7 @@ exports.handleRequest = async report => {
     console.log('ERROR: options missing or invalid');
   }
 };
+
+// ########## OPERATION
+
+handleRequest(process.argv[2]);

package/samples/batches/weborgs.json

@@ -0,0 +1,16 @@
+{
+  "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/samples/scripts/tenon.json

@@ -0,0 +1,28 @@
+{
+  "what": "Test Wikipedia with tenon",
+  "strict": true,
+  "commands": [
+    {
+      "type": "launch",
+      "which": "chromium",
+      "what": "Chromium browser"
+    },
+    {
+      "type": "url",
+      "which": "https://en.wikipedia.org/wiki/Main_Page",
+      "what": "Wikipedia English home page"
+    },
+    {
+      "type": "tenonRequest",
+      "withNewContent": true,
+      "id": "a",
+      "what": "tenon request"
+    },
+    {
+      "type": "test",
+      "which": "tenon",
+      "id": "a",
+      "what": "result of prior tenon request"
+    }
+  ]
+}

package/tests/tenon.js

@@ -0,0 +1,123 @@
+/*
+  tenon
+  This test processes a previously requested test by the Tenon API.
+*/
+const https = require('https');
+// Wait until a time limit in seconds expires.
+const wait = timeLimit => new Promise(resolve => setTimeout(resolve, 1000 * timeLimit));
+exports.reporter = async (tenonData, id) => {
+  if (tenonData && tenonData.accessToken && tenonData.requestIDs && tenonData.requestIDs[id]) {
+    // Shared request options.
+    const requestOptions = {
+      host: 'tenon.io',
+      path: `/api/v2/${tenonData.requestIDs[id]}`,
+      port: 443,
+      protocol: 'https:',
+      headers: {
+        Authorization: `Bearer ${tenonData.accessToken}`,
+        'Cache-Control': 'no-cache'
+      }
+    };
+    // Gets the test status.
+    const getStatus = async () => {
+      const testStatus = await new Promise((resolve, reject) => {
+        requestOptions.method = 'HEAD';
+        const statusRequest = https.request(requestOptions, statusResponse => {
+          const {statusCode} = statusResponse;
+          resolve(statusCode);
+        });
+        statusRequest.on('error', error => {
+          console.log(`ERROR getting Tenon test status (${error.message})`);
+          reject(`ERROR getting Tenon test status (${error.message})`);
+        });
+        statusRequest.end();
+      });
+      return testStatus;
+    };
+    // Gets the test result.
+    const getResult = async () => {
+      const testResult = await new Promise(resolve => {
+        requestOptions.method = 'GET';
+        const resultRequest = https.request(requestOptions, resultResponse => {
+          let resultJSON = '';
+          resultResponse.on('data', chunk => {
+            resultJSON += chunk;
+          });
+          resultResponse.on('end', () => {
+            try {
+              const result = JSON.parse(resultJSON);
+              resolve(result);
+            }
+            catch(error) {
+              console.log(`ERROR getting Tenon test result (${resultJSON.slice(0, 80)} …)`);
+              resolve({
+                error: 'ERROR getting Tenon test result',
+                resultStart: resultJSON.slice(0, 80)
+              });
+            }
+          });
+        });
+        resultRequest.end();
+      });
+      return testResult;
+    };
+    // Get the test status (not reliable: may say 200 instead of 202).
+    let testStatus = await getStatus();
+    // If the test is still in the Tenon queue:
+    if (testStatus === 202) {
+      // Wait 5 seconds.
+      await wait(5);
+      // Get the test status again.
+      testStatus = await getStatus();
+    }
+    // If the test has allegedly been completed:
+    if (testStatus ===  200) {
+      // Get the test result.
+      let testResult = await getResult();
+      // If the test is still in the Tenon queue:
+      let {status} = testResult;
+      if (status === 202) {
+        // Wait 5 seconds.
+        await wait(5);
+        // Get the test result again.
+        testResult = await getResult();
+        // If the test is still in the Tenon queue:
+        status = testResult.status;
+        if (status === 202) {
+          // Wait 15 more seconds.
+          await wait(15);
+          // Get the test result again.
+          testResult = await getResult();
+          status = testResult.status;
+        }
+      }
+      // If the test has really been completed:
+      if (status === 200) {
+        // Return its result.
+        return {result: testResult};
+      }
+      // Otherwise, i.e. if the test is still running or failed:
+      else {
+        return {result: {
+          error: 'ERROR: Tenon result not retrieved',
+          status
+        }};
+      }
+    }
+    // Otherwise, if the test is still running after a wait for its status:
+    else {
+      // Report the test status.
+      return {result: {
+        error: 'ERROR: test status not completed',
+        testStatus
+      }};
+    }
+  }
+  else {
+    return {
+      result: {
+        error: 'ERROR: tenon authorization and test data incomplete'
+      }
+    };
+  }
+};