@suffolklitlab/alkiln 4.6.2 → 4.7.2

package/lib/steps.js

@@ -24,6 +24,13 @@ const files = require('./utils/files' );
 
 /* Of Note:
 - We're using `*=` for selectors because sometimes da text has funny characters in it that are hard to anticipate
+- Can't use elem[ scope.activate ](). It works locally, but errors on GitHub
+  with "Node is not visible or not an HTMLElement". We're not using a custom Chromium version
+  Unfortunately, this won't catch an invisible element. Hopefully we'd catch it before click
+  attempts are made. "Tap" on mobile is more complex to implement ourselves.
+  See https://stackoverflow.com/a/56547605/14144258
+  and other convos around it. We haven't made it public that the device
+  can customized. Until we do that, we'll just use "click" all the time.
 */
 
 
@@ -61,7 +68,8 @@ regex thoughts: https://stackoverflow.com/questions/171480/regex-grabbing-values
 
 // Hoping that most load and download times will be under 30 seconds.
 // TODO: Check what average load and download times are in our current interviews.
-setDefaultTimeout( 30 * 1000 );
+let default_timeout = 30 * 1000
+setDefaultTimeout( default_timeout );
 
 let click_with = {
   mobile: 'tap',
@@ -69,10 +77,12 @@ let click_with = {
 };
 
 BeforeAll(async () => {
-  scope.timeout = 30 * 1000;
   scope.showif_timeout = 600;
   scope.report = new Map();
 
+  // Start tracking whether server is up and running
+  scope.track_server_status( scope );
+
   // Store path names for files and docs created for the tests
   scope.paths = {};
   // Test setup should have created this filepath. Run setup if there's a problem with this.
@@ -92,9 +102,21 @@ BeforeAll(async () => {
 });
 
 Before(async (scenario) => {
+  // Create browser, which can't be created in BeforeAll() where .driver doesn't exist for some reason
+  if (!scope.browser) {
+    scope.browser = await scope.driver.launch({ headless: !session_vars.get_debug(), devtools: session_vars.get_debug() });
+  }
+  // Clean up all previously existing pages
+  for (const page of await scope.browser.pages()) { 
+    await page.close();
+  }
+  // Make a new page
+  scope.page = await scope.browser.newPage()
+
   scope.scenario_id = uuidv4();
   scope.expected_status = null;
   scope.expected_in_report = null;
+  scope.server_reload_promise = null;
 
   await scope.addReportHeading(scope, {scenario});
   // Make folder for this Scenario in the all-tests artifacts folder
@@ -119,7 +141,7 @@ Before(async (scenario) => {
   scope.passed_all_for_a11y = true;
 
   // Reset default timeout
-  scope.timeout = 30 * 1000;
+  scope.timeout = default_timeout;
 });
 
 // Add a check for an error page before each step? After each step?
@@ -132,47 +154,9 @@ Before(async (scenario) => {
 //#####################################
 
 Given(/I start the interview at "([^"]+)"(?: in lang "([^"]+)")?/, {timeout: -1}, async (file_name, language) => {  // √
-  // NO CUCUMBER TIMEOUT. Handling our own timeouts to deal with initial scenario load.
-  // It involves wrapping everything in custom timeouts. See
-  // https://github.com/SuffolkLITLab/ALKiln/issues/389#issuecomment-984844240
-  let max_load_attempts = 3;
-  let num_attempts = 0;
-  // First test long load time discussion:
-  // https://github.com/SuffolkLITLab/ALKiln/issues/389#issuecomment-984844240
-  while ( num_attempts < max_load_attempts ) {
-
-    num_attempts++;
-    let timeout_message = `Failed to load "${ file_name }" after ${ num_attempts } tries. `
-      + `Each try gave the page ${ scope.timeout/1000 } seconds to load.`;
-    
-    let loaded = new Promise(async ( resolve, reject ) => {
-      // Exit if timeout is exceeded. Reject only if final attempt failed
-      let page_timeout = setTimeout(function() {
-        if ( num_attempts === max_load_attempts ) { reject( `${ timeout_message } Internal timeout.` ); }
-        else { resolve( false ); }  // Give it another shot
-      }, scope.timeout);
-      // self-invoke an anonymous async function so we don't have to
-      // abstract the details of resolving and rejecting.
-      (async function() {
-        try {
-          await scope.load( scope, file_name );
-          resolve( true );
-        } catch ( err ) {
-          // Only fail on final attempt. Actual error should be logged by cucumber output.
-          if ( num_attempts === max_load_attempts ) {
-            // This may not be the most useful error for us framework developers, but
-            // we'll have the rejection error I hope
-            await scope.addToReport(scope, { type: `error`, value: timeout_message });
-            reject( err );
-          } else { resolve( false ); }  // Give it another shot
-        } finally {
-          clearTimeout( page_timeout );  // prevent temporary hang at end of tests
-        }
-      })();
-    });  // ends loaded promise
-    await loaded;
-    if ( loaded === true ) { break; }
-  }  // ends while attempting to load page
+
+  // Load the right interview page
+  await scope.load( scope, file_name );
   
   // The page timeout is set in here too in case someone set a custom timeout
   // before a page was loaded.
@@ -276,13 +260,13 @@ Given(/I (?:sign|log) ?(?:in)?(?:on)?(?:to the server)? with(?: the email)? "([^
   * I sign on with the email "USER1_EMAIL" and the password "USER1_PASSWORD" SECRETs
   * I log in with "USER1_EMAIL" and "USER1_PASSWORD"
   */
-  return wrapPromiseWithTimeout(
-    scope.steps.sign_in( scope, {
-      email_secret_name: email,
-      password_secret_name: password
-    }),
-    scope.timeout
-  );
+  // Exiting the custom timeout happens in scope.tapElement() if needed
+  // Couldn't test the timeout for tapping the button because there's not
+  // enough of a pause between initial navigation and pressing button.
+  await scope.steps.sign_in( scope, {
+    email_secret_name: email,
+    password_secret_name: password
+  });
 });
 
 // I am using a mobile/pc
@@ -304,6 +288,7 @@ When(/I am using an? (.*)/, async ( device ) => {
 
 Given(/the max(?:imum)? sec(?:ond)?s for each step (?:in this scenario )?is (\d+)/i, async ( seconds ) => {
   /* At any time, set a custom timeout for the scenario. */
+  // TODO: Add 1 second to this to allow other steps to not fail, like "I wait n seconds"
   scope.timeout = parseInt( seconds ) * 1000;
   
   // Cucumber timeouts are made custom for each step that needs it
@@ -334,21 +319,30 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
   // It also seems harsh, but more reliable.
   // Ask developers what they'd like.
 
-  let supported_table = await scope.normalizeTable( scope, { var_data: raw_var_data.hashes() });
+
+  let supported_table = await scope.normalizeTable( scope, { raw_var_data });
 
   let { question_has_id, id, id_matches } = await scope.examinePageID( scope, target_id );
-  // Until we reach the final page or hit an error
+  // Until we reach the target page, hit an error, or time out (take too long)
   while ( !id_matches ) {
     let custom_timeout = new Promise(function( resolve, reject ) {
-      // Set up the timeout
-      let page_timeout = setTimeout(function() {
-        let timeout_message = `The target id was "${ target_id }", but it took too long` +
-        ` to try to reach it (over ${ scope.timeout/1000/60 } min). The test got stuck on "${ id }".`
-        reject( timeout_message );
-      }, scope.timeout);
+
+      // Set up the timeout that avoids infinite loops
+      let on_page_timeout = async function() {
+
+        let non_reload_report_msg = `The target id was "${ target_id }", but it took `
+        + `too long to try to reach it (over ${ scope.timeout/1000/60 } min). The `
+        + `test got stuck on "${ id }".`
+        let error = non_reload_report_msg;
+        await scope.handle_page_timeout_error( scope, { non_reload_report_msg, error });
+      };  // Ends on_page_timeout()
+      let page_timeout_id = setTimeout(on_page_timeout, scope.timeout);
 
       // self-invoke an anonymous async function so we don't have to
       // abstract the details of resolving and rejecting.
+      // If we need to call recursively, signature function might look like:
+      // func( scope, { resolve, reject, supported_table, page_timeout_id })
+      // Maybe list of timeout and/or interval ids in state that can all be cleared at once?
       (async function() {
         try {
           let { question_has_id, id, id_matches } = await scope.examinePageID( scope );
@@ -364,9 +358,12 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
           if ( error.was_found ) { await scope.throwPageError( scope, { id: id }); }
           resolve();
         } catch ( err ) {
+          let err_msg = `Error occurred when tried to answer fields on question "${ id }".`
+          scope.addToReport( scope, { type: `error`, value: err_msg });
+          // Throw error instead?
           reject( err );
         } finally {
-          clearTimeout( page_timeout );  // prevent temporary hang at end of tests
+          clearTimeout( page_timeout_id );  // prevent temporary hang at end of tests
         }
       })();
     });  // ends custom_timeout for setFields
@@ -458,7 +455,7 @@ Then(/I take a screenshot ?(?:named "([^"]+)")?/, { timeout: -1 }, async ( name
 /* Here to make writing tests more comfortable. */
 When("I do nothing", async () => { await scope.afterStep(scope); });  // √
 
-Then('the question id should be {string}', { timeout: -1 }, async ( question_id ) => {
+Then(/the (?:question|page|screen) id should be "([^"]+)"/i, { timeout: -1 }, async ( question_id ) => {
   /* Looks for a sanitized version of the question id as it's written
   *     in the .yml. docassemble's way */
   let { question_has_id, id, id_matches } = await scope.examinePageID( scope, question_id );
@@ -641,7 +638,7 @@ Then(/the "([^"]+)" link opens in (a new window|the same window)/, async (linkTe
   let [link] = await scope.page.$x(`//a[contains(text(), "${linkText}")]`);
 
   let prop_obj = await link.getProperty('target');
-  let target = await await prop_obj.jsonValue();
+  let target = await prop_obj.jsonValue();
 
   let should_open_a_new_window = which_window === 'a new window';
   let opens_a_new_window = target === '_blank';
@@ -735,31 +732,25 @@ Then(/the "([^"]+)" link opens a working page/, { timeout: -1 }, async ( linkTex
 When('I tap to continue', { timeout: -1 }, async () => {
   // Any selectors for this seem somewhat precarious
   // No data will cause an automatic continue when `ensure_navigation` is true
-  return wrapPromiseWithTimeout(
-    scope.setFields( scope, { var_data: [], ensure_navigation: true }),
-    scope.timeout
-  );
+
+  // Exiting the custom timeout happens in scope.tapElement() where we can
+  // check if the server is reloading
+  await scope.setFields( scope, { var_data: [], ensure_navigation: true });
 });
 
 When(/I tap the "([^"]+)" tab/i, { timeout: -1 }, async ( tabId ) => {
-  return wrapPromiseWithTimeout(
-    scope.tapTab( scope, tabId ),
-    scope.timeout
-  )
+  // Exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.tapTab( scope, tabId );
 });
 
 When(/I tap the "([^"]+)" element$/i, { timeout: -1 }, async ( elemSelector ) => {
-  return wrapPromiseWithTimeout(
-    scope.tapElementBySelector( scope, elemSelector, 2000 ),
-    scope.timeout
-  )
+  // Exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.tapElementBySelector( scope, elemSelector, 2000 );
 });
 
 When(/I tap the "([^"]+)" element and wait ([0-9]+) second(?:s)?/i, { timeout: -1 }, async ( elemSelector, waitTime ) => {
-  return wrapPromiseWithTimeout(
-    scope.tapElementBySelector( scope, elemSelector, waitTime * 1000 ),
-    scope.timeout
-  )
+  // Exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.tapElementBySelector( scope, elemSelector, waitTime * 1000 )
 });
 
 When(/I check the page for (?:accessibility|a11y) issues/i, {timeout: -1}, async () => {
@@ -780,10 +771,166 @@ When(/I check all pages for (?:accessibility|a11y) issues/i, {timeout: -1}, asyn
 // UI element interaction
 //#####################################
 
+// -------------------------------------
+// --- RANDOM INPUT ---
+When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { timeout: -1 }, async ( max_pages_str ) => {
+  /** Give random answers until the user can't continue any more.
+  * 
+  * Variations:
+  * I answer randomly for at most 1 page
+  * I answer randomly for at most 10 pages
+  * I answer randomly for at most 101 screens
+  */
+  // Give each screenshots folder a time-stamped name in case the dev gets clever
+  // and use the same Scenario to run multiple randomized tests.
+  let timestamp = files.readable_date();
+  let random_input_path = `${ scope.paths.scenario }/random_answers_screenshots-${ timestamp }`
+  scope.paths.random_screenshots = random_input_path;
+  fs.mkdirSync( scope.paths.random_screenshots );
+  await scope.addToReport( scope, {
+    type: 'row',
+    value: `Testing interview with random input (in ${ random_input_path })`
+  });
+
+  // Force the dev to prevent infinite loops
+  let max_pages = parseInt( max_pages_str );
+  let curr_page_num = 0;
+
+  // While a continue-type button is on the current page, fill out
+  // the fields and then try to continue
+  let buttons_exist = true;
+  while ( buttons_exist && curr_page_num < max_pages ) {
+
+    curr_page_num = curr_page_num + 1;
+    let { id } = await scope.examinePageID( scope, `no target id` );
+
+    let no_content_err = `The interview seemed to run into an error page`
+      + ` after the page with the question id "${ id }".`
+      + ` See the screenshot in "${ random_input_path }".`;
+
+    let has_thrown = false;
+    // Ensure no infinite loop, but each page has a full timeout to run
+    let custom_timeout = new Promise(async function( resolve, reject ) {
+
+      // Set up timeout to stop infinite loops
+      let page_timeout_id = setTimeout(async function() {
+        
+        // Make sure to only throw once
+        if ( has_thrown ) { return; }
+        else { has_thrown = true; }
+
+        let has_content = await scope.has_interview_content( scope );
+
+        if ( !has_content ) {
+          await scope.addToReport( scope, {
+            type: `error`,
+            value: no_content_err
+          });
+          reject( no_content_err );
+
+        } else {
+          let timeout_message = `The page with an id of "${ id }" took too long`
+            + ` to fill with random answers (over ${ scope.timeout/1000/60 } min).`
+          await scope.addToReport( scope, { type: `error`, value: timeout_message });
+          reject( timeout_message );
+        }
+
+      }, scope.timeout );
+
+      // self-invoke an anonymous async function so we don't have to
+      // abstract the details of resolving and rejecting.
+      (async function() {
+        try {
+
+          // Set all the fields on the page
+          let buttons = await scope.steps.set_random_page_vars( scope );
+
+          // Take a screenshot of the page before continuing or ending
+          await scope.page.screenshot({
+            path: `${ scope.paths.random_screenshots }/random-${ Date.now() }.jpg`,
+            type: `jpeg`,
+            fullPage: true
+          });
+
+          // Prep for the next loop to possibly stop. Signature page buttons
+          // don't count as buttons in the way our field detects them
+          buttons_exist = buttons.length > 0;
+          // If there were any buttons, pick a random one to try to press
+          if ( buttons_exist ) {
+            await scope.set_random_input_for.buttons( scope, { fields: buttons });
+          } else {
+            // If can theoretically continue, try to. Also prep to
+            // stop or continue for the next loop
+            buttons_exist = await scope.continue_exists( scope );
+            if ( buttons_exist ) {
+              await scope.continue( scope );
+            }  // ends if continue exists
+          }  // ends if buttons_exist
+
+          let has_content = await scope.has_interview_content( scope );
+          if ( !has_content ) {
+
+            // Throw an error if there's no interview content
+            // Make sure to only throw once
+            if ( !has_thrown ) {
+              has_thrown = true;
+              await scope.addToReport( scope, {
+                type: `error`,
+                value: no_content_err
+              });
+              reject( no_content_err );
+            }
+
+          }  // ends if !has_content
+
+          if ( buttons_exist ) {
+            process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
+          }         
+
+          resolve();
+
+        } catch ( error ) {
+
+          // Make sure to only throw once
+          if ( has_thrown ) { return; }
+          else { has_thrown = true; }
+
+          // Throw a specific error if there's no interview content
+          let has_content = await scope.has_interview_content( scope );
+          if ( !has_content ) {
+            await scope.addToReport( scope, {
+              type: `error`,
+              value: no_content_err
+            });
+            reject( no_content_err );
+
+          // Otherwise throw a generic error
+          } else {
+            let err_msg = `The page with the question id "${ id }" errored when trying to fill`
+              + ` it with random answers: ${ error.name }`
+            await scope.addToReport( scope, { type: `error`, value: err_msg });
+            reject( error );
+          }  // ends if !has_content
+
+        } finally {
+          // prevent temporary hang at end of tests
+          clearTimeout( page_timeout_id );
+        }
+      })();
+
+    });  // ends custom_timeout for set_random_page_vars
+
+    await custom_timeout;
+
+  }  // ends while continue_exists
+
+
+});  // Ends random input
+
 // -------------------------------------
 // --- VARIABLES-BASED STEPS ---
 
-When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( var_name, set_to ) => {
+When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( var_name, answer ) => {
   /* Set a non-story table variable (with or without a choice associated with it) to a value. Set:
   *  - Buttons associated with variables
   *  - Dropdowns
@@ -794,20 +941,18 @@ When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async (
   *
   * Variations:
   * 1. I set the var "benefits['SSI']" to "false"
-  * 1. I set the var "rent_interval" to "weekly"
+  * 1. I set the variable "rent_interval" to "weekly"
   */
-  return wrapPromiseWithTimeout(
-    scope.steps.set_regular_var( scope, var_name, set_to ),
-    scope.timeout
-  );
+  // Exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.steps.set_regular_var( scope, var_name, answer )
+
 });
 
 When(/I set the var(?:iable)? "([^"]+)" to ?(?:the)? ?(?:GitHub)? secret "([^"]+)"/i, { timeout: -1 }, async ( var_name, set_to_env_name ) => {
   /* Set a non-story table variable to a secrete value. Same as the above, but reads the value from `process.env` */
-  return wrapPromiseWithTimeout(
-    scope.steps.set_secret_var( scope, var_name, set_to_env_name ),
-    scope.timeout
-  );
+  // This could theoretically tap an element, so
+  // exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.steps.set_secret_var( scope, var_name, set_to_env_name )
 });
 
 
@@ -826,10 +971,8 @@ Then(/I upload "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( filenames, var_
 
 When('I tap the defined text link {string}', { timeout: -1 }, async ( phrase ) => {
   /** Tap a link that doesn't navigate. Depends on the language of the text. */
-  return wrapPromiseWithTimeout(
-    scope.steps.tap_term( scope, phrase ),
-    scope.timeout
-  );
+  // exiting the custom timeout happens in scope.tapElement() if needed
+  await scope.steps.tap_term( scope, phrase );
 });
 
 Then('I sign', { timeout: -1 }, async () => {
@@ -846,6 +989,9 @@ When(/I download "([^"]+)"$/, { timeout: -1 }, async ( filename ) => {
   *    WARNING: Must not contain any characters that are totally unique to that
   *    page load. Just stick to the name of the file.
   */
+  // TODO:
+  // This should be using `scope.tapElement()`? When someone clicks on a link to
+  // download a document, it sends a request to the server, which could be reloading
   return wrapPromiseWithTimeout(
     scope.steps.download( scope, filename ),
     scope.timeout
@@ -938,6 +1084,7 @@ Given(/the final Scenario status should be "(passed|failed)"/i, async ( expected
 //#####################################
 
 After(async function(scenario) {
+
   // The accessibility failures don't happen til the end, so the rest of the test can continue
   if ( scope.check_all_for_a11y && !scope.passed_all_for_a11y) {
     // The fact that the scenario failed has already been noted earlier in the report
@@ -954,14 +1101,15 @@ After(async function(scenario) {
       if ( scope.page ) { await scope.page.waitForTimeout( 60 * 1000 ); }
     }
 
-    await scope.addToReport(scope, { type: `outcome`, value: `**-- Scenario Failed --**` });
     if ( scope.page ) {
-      if ( scope.disable_error_screenshot ) {
+
+      if ( !!scope.disable_error_screenshot ) {
         scope.addToReport(scope, {
           type: `row`,
           value: `For security, ALKiln will not create a screenshot for this error. It's possible a secret is being used on this screen.`
         });
       } else {
+
         // Save/download a picture of the screen that's showing during the unexpected status
         // Save one copy in the outer-most artifact folder
         let scenario_filename = await scope.getSafeScenarioFilename( scope, { prefix: `error_on` });
@@ -982,11 +1130,12 @@ After(async function(scenario) {
       }  // ends if scope.disable_error_screenshot
     }  // ends if scope.page exists
 
-  }  // ends if not passed
+    // This has to come after the security message or security message doesn't print. Not sure why.
+    if (scenario.result.status === `FAILED`) {
+      await scope.addToReport(scope, { type: `outcome`, value: `**-- Scenario Failed --**` });
+    }
 
-  if (scenario.result.status === `FAILED`) {
-    await scope.addToReport(scope, { type: `outcome`, value: `**-- Scenario Failed --**` });
-  }
+  }  // ends if not passed
 
   let original_scenario_status = scenario.result.status;
 
@@ -995,43 +1144,44 @@ After(async function(scenario) {
     let expected = scope.expected_status;
     scope.expected_status = null;  // reset for next Scenario
     expect( scenario.result.status ).to.equal( expected );
+    // If the status was as expected, pass this criteria
+    scenario.result.status = `PASSED`;
   }
   if ( scope.expected_in_report && scope.expected_in_report.length > 0) {
     let expected = scope.expected_in_report;
     // Reset report values no matter what so they don't mess up future scenarios
     scope.expected_in_report = null;
     let all_were_included = await scope.reportIncludesAllExpected( scope, { expected });
+
     if ( all_were_included ) { scenario.result.status = `PASSED`; }
+    else { scenario.result.status = `FAILED`; }
   }
 
   // If there is a page open, then sign out and close it
   if ( scope.page ) {
-    // Make sure the new interview really starts fresh. Sometimes insufficient.
-    // Also, often is a failure point.
-    // Consider, instead, catching the reload error for a bad restart and just
-    // re-trying at that point.
+    // Catch a possible reload error.
+
+    // TODO: implement and use scope.handle_possible_timeout()
     try {
+      // puppeteer will ensure proper timeout.
       await scope.page.goto(`${ session_vars.get_da_server_url() }/user/sign-out`, {waitUntil: `domcontentloaded`});  
-    } catch ( err ) {
-      if ( session_vars.DEBUG ) {
-        console.log( `Trying to reset for the next test a second time because the first time failed.` );
-      }
 
-      try {
-        await scope.page.goto(`${ session_vars.get_da_server_url() }/user/sign-out`, {waitUntil: `domcontentloaded`});  
-      
-      } catch ( err ) {
-        await scope.addToReport(scope, {
-          type: `warning`,
-          value: `This test ${ original_scenario_status }, but also there `
-            + `was an error while trying to reset for the next test. You can try `
-            + `re-running the test or checking your server.`
-        });
-      }
-    }
-    
-    await scope.page.close();
-    scope.page = null;
+    } catch ( error ) {
+
+      if ( error.name === `TimeoutError` ) {
+        // TODO: Should a more specific message about signing out get into the report no matter what?
+        // If so, what should the message be in order to not get confused with these other messages?
+        let non_reload_report_msg = `It took too long to sign out in preparation for the next test.`;
+        await scope.handle_page_timeout_error( scope, { non_reload_report_msg, error });
+      } else {
+        // Throw any non-timeout error
+        let err_msg = `Error occurred when ALKiln tried to sign out in preparation for the next test.`
+        scope.addToReport( scope, { type: `error`, value: err_msg });
+        throw error;
+      }  // ends if error is timeout error
+
+    }  // ends try/catch
+
   }  // ends if scope.page
 
   // Add report text to Scenario folder after everything has been added to the report
@@ -1043,6 +1193,9 @@ After(async function(scenario) {
 });
 
 AfterAll(async function() {
+  // Stop collecting server response statuses
+  scope.stop_tracking_server_status = true;
+  
   let report = await scope.getPrintableReport( scope );
   // Log the report. Can't get this.attach() or this.log() to work in `After()` or here.
   // May need newest version of cucumberjs

package/lib/utils/files.js

@@ -8,6 +8,7 @@ files.readable_date = function() {
   *  match the workflow artifact date format. */
   let date = new Date();  // now
   let str = date.toLocaleString('en-GB', { timeZone: 'UTC' });
+  // To properly get the year/month/day format, look at https://stackoverflow.com/a/48729396/14144258
   let fancy_str = str.replace(/\//g, '-').replace(',', ' at').replace(':', 'hrs ').replace(':', 'mins ') + 'secs UTC';
   return fancy_str;
 };  // Ends files.readable_date()

package/lib/utils/session_vars.js

@@ -25,6 +25,7 @@ module.exports = session_vars;
 session_vars.get_debug = function () { return process.env.DEBUG || null; };
 session_vars.get_dev_api_key = function () { return process.env.DOCASSEMBLE_DEVELOPER_API_KEY || null; };
 session_vars.get_repo_url = function () { return process.env.REPO_URL || null; };
+session_vars.get_server_reload_timeout = function () { return process.env.SERVER_RELOAD_TIMEOUT_SECONDS || null; };
 session_vars.is_dev_env = function () { return process.env.DEV || null; }
 
 // More complex logic

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "4.6.2",
+  "version": "4.7.2",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
     "test": "npm run unit && npm run langs_setup && npm run cucumber -- $@",
     "cucumber_base": "run_cucumber(){ ./node_modules/.bin/cucumber-js \"$@\"; status=$?; ./lib/utils/clean_reports.js; return $status; }; run_cucumber",
-    "cucumber": "run_base(){ npm run cucumber_base -- \"$@\" tests/features/*.feature; }; run_base",
+    "cucumber": "run_base(){ npm run cucumber_base -- \"$@\" tests/features/*.feature --retry 1; }; run_base",
     "cucumber_external": "run_cucumber(){ tmp_path=`pwd`; ( new_path=\"$1\"; shift; cd \"$new_path\"; npm run --prefix \"${tmp_path}\" cucumber_base -- \"$@\" \"$new_path\"/docassemble/*/data/sources/*.feature;) }; run_cucumber",
     "langs": "npm run langs_setup && ./node_modules/.bin/cucumber-js --require ./lib/index.js tests/features/*_lang*.feature",
     "langs_setup": "./lib/utils/langs.js 'tests/features/*.feature'",
@@ -37,6 +37,7 @@
   "dependencies": {
     "@axe-core/puppeteer": "4.4.2",
     "@cucumber/cucumber": "7.3.2",
+    "@faker-js/faker": "^7.3.0",
     "axios": "0.24.0",
     "chai": "4.2.0",
     "cheerio": "1.0.0-rc.10",

package/tests/features/interactive_steps.feature

@@ -131,4 +131,4 @@ Scenario: tap element with an error
   is there a typo?
   """
   Given I start the interview at "test_taps"
-  And I tap the "Tests-not_there-tab" tab
+  And I tap the "Tests-not_there-tab" tab