@suffolklitlab/alkiln 4.7.0 → 4.8.0

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
@@ -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 () => {
@@ -790,35 +781,61 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
   * I answer randomly for at most 10 pages
   * I answer randomly for at most 101 screens
   */
-  scope.paths.random_screenshots = `${ scope.paths.scenario }/random_answers_screenshots`;
+  // 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 button is on the current page, fill out
+  // While a continue-type button is on the current page, fill out
   // the fields and then try to continue
-  // let continue_exists = true;
-  // while ( continue_exists && curr_page_num < max_pages ) {
   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() {
         
-        let timeout_message = `The page with an id of "${ id }" took too long `
-          + `to fill it with random answers (over ${ scope.timeout/1000/60 } min).`
-        await scope.addToReport( scope, { type: `error`, value: timeout_message });
-        throw( timeout_message );
+        // Make sure to only throw once
+        if ( has_thrown ) { return; }
+        else { has_thrown = true; }
 
-      }, scope.timeout);
+        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.
@@ -830,7 +847,7 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
 
           // Take a screenshot of the page before continuing or ending
           await scope.page.screenshot({
-            path: `${ scope.paths.random_screenshots }/${ Date.now() }.jpg`,
+            path: `${ scope.paths.random_screenshots }/random-${ Date.now() }.jpg`,
             type: `jpeg`,
             fullPage: true
           });
@@ -848,7 +865,23 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
             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
@@ -856,11 +889,28 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
 
           resolve();
 
-        } catch ( err ) {
-          let err_msg = `The page with the "${ id }" errored when trying to fill `
-            + `it with random answers: ${ err.name }`
-          await scope.addToReport( scope, { type: `error`, value: err_msg });
-          throw( err );
+        } 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
@@ -891,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, answer ),
-    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 )
 });
 
 
@@ -923,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 () => {
@@ -943,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
@@ -1035,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
@@ -1051,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` });
@@ -1079,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;
 
@@ -1092,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
@@ -1140,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

@@ -5,10 +5,20 @@ let files = {};
 
 files.readable_date = function() {
   /* Return the current timestamp in a human-readable filename-safe format to
-  *  match the workflow artifact date format. */
+  *  match the workflow artifact date format.
+  * 
+  * See https://stackoverflow.com/a/48729396/14144258 and https://stackoverflow.com/a/6040556/14144258
+  */
   let date = new Date();  // now
-  let str = date.toLocaleString('en-GB', { timeZone: 'UTC' });
-  let fancy_str = str.replace(/\//g, '-').replace(',', ' at').replace(':', 'hrs ').replace(':', 'mins ') + 'secs UTC';
+  let day = ("0" + date.getUTCDate()).slice(-2);
+  let month = ("0" + date.getUTCMonth() + 1).slice(-2);
+  let year = date.getUTCFullYear();
+  let hours = ("0" + date.getUTCHours()).slice(-2);
+  let mins = ("0" + date.getUTCMinutes()).slice(-2);
+  let secs = ("0" + date.getUTCSeconds()).slice(-2);
+  let msecs = ("00" + date.getUTCMilliseconds()).slice(-3);
+
+  let fancy_str = `${ year }-${ month }-${ day } at ${ hours }hr ${ mins }min ${ secs }sec ${ msecs }ms 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.7.0",
+  "version": "4.8.0",
   "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'",

package/tests/features/interactive_steps.feature

@@ -132,8 +132,3 @@ Scenario: tap element with an error
   """
   Given I start the interview at "test_taps"
   And I tap the "Tests-not_there-tab" tab
-
-@i5 @random
-Scenario: I answer randomly till the end
-  Given I start the interview at "all_tests"
-  And I answer randomly for at most 50 pages

package/tests/features/random_input.feature

@@ -3,13 +3,29 @@ Feature: Assembly Line package-specific Steps
 
 # In tag names, 'ri' is for 'random input'
 
-@slow @ri1 @random
+@fast @ri1 @random
 Scenario: I fill in random input till the end
   Given I start the interview at "test_random_input"
   And I answer randomly for at most 20 pages
   Then the question id should be "end"
 
-@slow @ri2 @random
+@fast @ri2 @random
 Scenario: I fill in random input for 1 page
   Given I start the interview at "test_random_input"
   And I answer randomly for at most 1 page
+
+# Should create two unique folders for random step screenshots which
+# must be checked manually
+@fast @ri3 @random
+Scenario: I answer randomly till the end twice
+  Given I start the interview at "test_random_input"
+  And I answer randomly for at most 50 pages
+  Given I start the interview at "test_random_input"
+  And I answer randomly for at most 50 pages
+
+@fast @ri4 @random @error
+Scenario: Fail with error page from random input
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_missing_var_error_screen"
+  And the max seconds for each step in this scenario is 10
+  And I answer randomly for at most 3 pages