@suffolklitlab/alkiln 4.6.1 → 4.7.1

package/lib/steps.js

@@ -20,8 +20,10 @@ const { v4: uuidv4 } = require('uuid');
 const scope = require('./scope');
 const log = require('./utils/log');
 const session_vars = require('./utils/session_vars');
+const files = require('./utils/files' );
+
 /* Of Note:
-- We're using `*=` because sometimes da text has funny characters in it that are hard to anticipate
+- We're using `*=` for selectors because sometimes da text has funny characters in it that are hard to anticipate
 */
 
 
@@ -70,7 +72,23 @@ BeforeAll(async () => {
   scope.timeout = 30 * 1000;
   scope.showif_timeout = 600;
   scope.report = new Map();
-  fs.writeFileSync(log.debug_log_file, "");
+
+  // 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.
+  scope.paths.artifacts = session_vars.get_artifacts_path_name();
+  // For GitHub tests, use the artifacts folder that was created during setup
+  // For local tests, make a new folder for each time scenarios start
+  if ( !session_vars.is_dev_env() ) {
+    // Make a new folder to store all the files for this run of the tests
+    scope.paths.artifacts = files.make_artifacts_folder();
+    // Save its name in a file. `session_vars` can get it back later.
+    session_vars.save_artifacts_path_name( scope.paths.artifacts );
+  }
+  scope.paths.report = `${ scope.paths.artifacts }/report.txt`;
+
+  scope.paths.debug_log = `${ scope.paths.artifacts }/${ log.debug_log_file }`;
+  fs.writeFileSync( scope.paths.debug_log, "" );
 });
 
 Before(async (scenario) => {
@@ -79,7 +97,14 @@ Before(async (scenario) => {
   scope.expected_in_report = null;
 
   await scope.addReportHeading(scope, {scenario});
+  // Make folder for this Scenario in the all-tests artifacts folder
   scope.base_filename = await scope.getSafeScenarioBaseFilename(scope, {scenario});
+  // Add a date for uniqueness in case dev has accidentally copied a Scenario description
+  let date = files.readable_date();
+  scope.paths.scenario = `${ scope.paths.artifacts }/${ scope.base_filename }-${ date }`;
+  fs.mkdirSync( scope.paths.scenario );
+  // Store path name for this Scenario's individualized report
+  scope.paths.scenario_report = `${ scope.paths.scenario }/report.txt`;
 
   // Downloads
   scope.downloadComplete = false;
@@ -164,10 +189,9 @@ Given(/I start the interview at "([^"]+)"(?: in lang "([^"]+)")?/, {timeout: -1}
       // I've seen stuff take an extra moment or two. Shame to have it everywhere
       try {
         // Interview files should get downloaded to downloads folder
-        let docs_dir = await scope.getSafeScenarioFilename( scope, { prefix: `downloads` });
         await scope.page._client.send('Page.setDownloadBehavior', {
           behavior: 'allow',
-          downloadPath: path.resolve( docs_dir ),  // Save in root of this project
+          downloadPath: path.resolve( scope.paths.scenario ),  // Save in root of this scenario
         });
         resolve();
       } catch ( err ) { reject( err ); }
@@ -178,7 +202,11 @@ Given(/I start the interview at "([^"]+)"(?: in lang "([^"]+)")?/, {timeout: -1}
   await custom_download_behavior_timeout;
 
   // ---- EVENT LISTENERS ----
-  // Wait for possible download. From https://stackoverflow.com/a/51423688
+
+  // TODO: Wait for download to complete doesn't work. See notes in
+  // scope.js scope.detectDownloadComplete()
+
+  // ~Wait for possible download. From https://stackoverflow.com/a/51423688~
   scope.page.on('response', async response => {
     // Note: We can expect that only one file will be getting downloaded
     // at any one time since each step completes synchronously
@@ -190,7 +218,7 @@ Given(/I start the interview at "([^"]+)"(?: in lang "([^"]+)")?/, {timeout: -1}
       // destroyed when the page closes anyway.
 
       // Watch event on download folder or file
-      await fs.watchFile( docs_dir, function (curr, prev) {
+      await fs.watchFile( scope.paths.scenario, function (curr, prev) {
         // If current size eq to size from response then close
         if (parseInt(curr.size) === parseInt(response._headers['content-length'])) {
           // Lets the related function in `scope` know that the download
@@ -306,7 +334,8 @@ 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
@@ -430,7 +459,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 );
@@ -613,7 +642,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';
@@ -650,7 +679,7 @@ Then(/(?:the )?text(?: in)?(?: the)?(?: JSON)?(?: var)?(?:iable)?(?: )?"([^"]+)"
   */
 
   // Get JSON variable value
-  let { filename, json } = await scope.savePageJSONData( scope );
+  let { json_path, json } = await scope.savePageJSONData( scope );
   let actual_value = json.variables[ var_name ];
 
   // Add warning to report if value is not as expected
@@ -658,8 +687,8 @@ Then(/(?:the )?text(?: in)?(?: the)?(?: JSON)?(?: var)?(?:iable)?(?: )?"([^"]+)"
     await scope.addToReport( scope, {
       type: `error`,
       value: `The variable "${ var_name }" was not equal to the expected `
-        + `value on the "${ scope.page_id }" screen. Check the downloads `
-        + `file ${ filename } to see the page's JSON variables.`
+        + `value on the "${ scope.page_id }" screen. Check `
+        + `${ json_path } to see the page's JSON variables.`
     });
   }
 
@@ -735,11 +764,11 @@ When(/I tap the "([^"]+)" element and wait ([0-9]+) second(?:s)?/i, { timeout: -
 });
 
 When(/I check the page for (?:accessibility|a11y) issues/i, {timeout: -1}, async () => {
-  let { passed, axe_filename } = await wrapPromiseWithTimeout(
+  let { passed, axe_filepath } = await wrapPromiseWithTimeout(
     scope.checkForA11y(scope),
     scope.timeout
   )
-  let msg = `Found potential accessibility issues on the ${ scope.page_id } screen. Details in ${ axe_filename }.`;
+  let msg = `Found potential accessibility issues on the ${ scope.page_id } screen. Details in ${ axe_filepath }.`;
   expect( passed, msg ).to.be.true;
 });
 
@@ -752,10 +781,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
@@ -769,7 +954,7 @@ When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async (
   * 1. I set the var "rent_interval" to "weekly"
   */
   return wrapPromiseWithTimeout(
-    scope.steps.set_regular_var( scope, var_name, set_to ),
+    scope.steps.set_regular_var( scope, var_name, answer ),
     scope.timeout
   );
 });
@@ -926,25 +1111,40 @@ 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
-        let safe_filename = await scope.getSafeScenarioFilename( scope, { prefix: `error` });
-        await scope.page.screenshot({ path: `${ safe_filename }.jpg`, type: `jpeg`, fullPage: true });
+        // Save one copy in the outer-most artifact folder
+        let scenario_filename = await scope.getSafeScenarioFilename( scope, { prefix: `error_on` });
+        await scope.page.screenshot({
+          path: `${ scope.paths.artifacts }/${ scenario_filename }.jpg`,
+          type: `jpeg`,
+          fullPage: true
+        });
+        // Save another copy in the artifact's Scenario folder
+        let screenshot_name = `error_on`;
+        let { id } = await scope.examinePageID( scope, 'none to match' );
+        screenshot_name += `-${ id }`;
+        await scope.page.screenshot({
+          path: `${ scope.paths.scenario }/${ screenshot_name }.jpg`,
+          type: `jpeg`,
+          fullPage: true
+        });
       }  // 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;
 
@@ -953,13 +1153,17 @@ 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
@@ -991,6 +1195,13 @@ After(async function(scenario) {
     await scope.page.close();
     scope.page = null;
   }  // ends if scope.page
+
+  // Add report text to Scenario folder after everything has been added to the report
+  let current_report_obj = scope.report.get( scope.scenario_id );
+  let scenario_report_obj = [ scope.scenario_id, current_report_obj ];  // Mimic how loop works with `Map`
+  let report = await scope.getPrintableScenario( scope, { scenario: scenario_report_obj });
+  // Save the report as in the Scenario folder
+  fs.writeFileSync( scope.paths.scenario_report, report );
 });
 
 AfterAll(async function() {
@@ -1000,7 +1211,7 @@ AfterAll(async function() {
   console.log( `\n\n${ report }` );
 
   // Save/download the report as an artifact
-  fs.writeFileSync( `alkiln_report_${ Date.now() }.txt`, report );
+  fs.writeFileSync( scope.paths.report, report );
 
   // If there is a browser open, then close it
   if (scope.browser) {

package/lib/utils/clean_reports.js

@@ -2,22 +2,28 @@
 
 const fs = require('fs');
 const log = require('./log');
+const session_vars = require('./session_vars');
 
 // This is hardcoded information from `cucumber.js`. Once we move to cucumber 8, we should
-// change that the cucumber.json and actually parse the info from it. 
+// change that the cucumber.json and actually parse the info from it.
+// The file won't be used for anything other than detecting and removing color codes 
 let summary_file_name = 'cucumber-report.txt';
 fs.readFile(summary_file_name, 'utf8', (err, data) => {
   if (err) {
     console.error(err);
     return;
   }
+
   // Replace terminal color codes, if present
   // https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797#colors--graphics-mode
   data = data.replace(/\x1b\[[0-9][0-9]?[0-9]?m/g, '');
-  fs.appendFile(log.debug_log_file, data, err => {
+
+  // Put it in the correct file in the correct folder
+  let artifacts_path = session_vars.get_artifacts_path_name();
+  fs.appendFile( `${ artifacts_path }/${ log.debug_log_file }`, data, err => {
     if (err) {
       console.error(err);
       return;
     }
-  });
+  });  // Ends appendFileSync
 });

package/lib/utils/files.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const safe_filename = require('sanitize-filename');
+
+let files = {};
+
+files.readable_date = function() {
+  /* Return the current timestamp in a human-readable filename-safe format to
+  *  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()
+
+files.make_artifacts_folder = function (folder_name) {
+  /** Makes a folder in the root of the project, either with the given name
+  *   or with a default name.
+  * 
+  * Works for local development as well, unlike action.yml or the workflow file.
+  */
+  if (folder_name) {
+    folder_name = safe_filename( folder_name );
+  } else {
+    folder_name = `alkiln_tests_output-${ files.readable_date() }`
+  }
+
+  fs.mkdirSync( folder_name );
+  return folder_name;
+};  // Ends files.make_artifacts_folder()
+
+module.exports = files;
+

package/lib/utils/session_vars.js

@@ -21,9 +21,11 @@ const session_vars = {};
 module.exports = session_vars;
 
 // These default to null
+// TODO: How to isolate debug elsewhere so this file can use the logger?
 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.is_dev_env = function () { return process.env.DEV || null; }
 
 // More complex logic
 session_vars.get_setup_timeout_ms = function () {
@@ -80,9 +82,10 @@ session_vars.get_languages = function () {
 };  // Ends session_vars.get_languages()
 
 
-const project_name_file_path = `_al_test_project_name.json`;
+const runtime_config_path = `runtime_config.json`;
+const project_name_key = `da_project_name`;
 session_vars.save_project_name = function ( project_name ) {
-  /* Saves the name of the project to a file so deletion can use it later.
+  /* Saves the name of the project to a json obj so deletion can use it later.
   *    Built for local as well as remote testing. Assumes a kosher string.
   *    We avoided a list because of concerns over getting out of date.
   *    Should we try to prevent someone overwriting a previous project name?
@@ -90,16 +93,23 @@ session_vars.save_project_name = function ( project_name ) {
   * @param project_name { string } - purely alphanumeric string */
 
   // Warn local developers if file already exists
-  if ( fs.existsSync( project_name_file_path ) ) {
+  if ( fs.existsSync( runtime_config_path ) ) {
     let old_project_name = session_vars.get_project_name();
     let session_project_already_exists_msg = `ALKiln WARNING: `
       + `This session had a project name already: ${ old_project_name }. `
       + `A new project has now been created called ${ project_name }. `
       + `Remember to delete ${ old_project_name }`;
     console.warn( session_project_already_exists_msg );
+  } else {
+    // If the file doesn't exist, make one because next we need to read it
+    fs.writeFileSync( runtime_config_path, JSON.stringify( {}, null, 2 ) );
   }
 
-  let file = fs.writeFileSync( project_name_file_path, JSON.stringify( project_name ) );
+  // Get the json, changing it, and re-write the file from scratch
+  let json = JSON.parse( fs.readFileSync( runtime_config_path ) );
+  json[ project_name_key ] = project_name;
+  let file = fs.writeFileSync( runtime_config_path, JSON.stringify( json, null, 2 ) );
+
   if ( session_vars.get_debug() ) {
     console.log( `ALKiln debug: Stored name of Project "${ project_name }" locally.` );
   }
@@ -107,26 +117,59 @@ session_vars.save_project_name = function ( project_name ) {
 };  // Ends save_project_name()
 
 session_vars.get_project_name = function () {
-  /* Get the name of the current project  */
-  let project_name =  JSON.parse( fs.readFileSync( project_name_file_path ));
-  if ( session_vars.get_debug() ) { console.log( `Project name from file is "${ project_name }".` ); }
+  /* Get the name of the current docassemble Project  */
+  let json = JSON.parse( fs.readFileSync( runtime_config_path ));
+  let project_name = json[ project_name_key ] || null;
+  if ( session_vars.get_debug() ) { console.log( `ALKiln debug: Project name from file is "${ project_name }".` ); }
   return project_name;
 };  // Ends get_project_name()
 
 session_vars.delete_project_name = function () {
-  /* Delete the file storing the name of the docassemble project */
-  // Avoid race conditions possibly caused by checking for existence first
-  // Delete file if possible
+  /* Empty the key storing the name of the docassemble Project */
   try {
-    fs.unlinkSync( project_name_file_path );
-    console.log( `ALKiln: Deleted the file that stored the name of the Project.` );
+    // Get the json, changing it, and re-write the file from scratch
+    let json = JSON.parse( fs.readFileSync( runtime_config_path ));
+    json[ project_name_key ] = ``;
+    console.log( `ALKiln: Deleted the data that stored the name of the Project.` );
+    fs.writeFileSync( runtime_config_path, JSON.stringify( json, null, 2 ) );
     return true;
   } catch ( error ) {
-    console.warn( `ALKiln WARNING: Could not delete the Project name file. Error: ${ error }.` );
+    console.warn( `ALKiln WARNING: Could not delete the Project name data. Error: ${ error }.` );
     return false;
   }
 };
 
+// The file storing the artifacts path contains the name of the current artifacts folder.
+// The directory name it contains will be created or changed with each run of all the tests.
+// const file_storing_artifact_path = `_alkiln_test_artifacts_dir_name.json`;
+const artifacts_path_key = `artifacts_path`;
+session_vars.save_artifacts_path_name = function ( path_name ) {
+  /* Save a key with the name of the current artifacts folder in case it doesn't exist. */
+
+  // Get the json, changing it, and re-write the file from scratch
+  let json = JSON.parse( fs.readFileSync( runtime_config_path ) );
+  json[ artifacts_path_key ] = path_name;
+  let file = fs.writeFileSync( runtime_config_path, JSON.stringify( json, null, 2 ) );
+
+  if ( session_vars.get_debug() ) {
+    console.log( `ALKiln debug: Stored name of artifacts directory "${ path_name }" locally.` );
+  }
+  return file;
+};  // Ends get_project_name()
+
+session_vars.get_artifacts_path_name = function () {
+  /* Get the name of the current artifacts path. */
+  try {
+    let json = JSON.parse( fs.readFileSync( runtime_config_path ));
+    let path_name = json[ artifacts_path_key ];
+
+    if ( session_vars.get_debug() ) { console.log( `ALKiln debug: Artifacts directory is "${ path_name }".` ); }
+    return path_name;
+  } catch ( error ) {
+    return null;
+  }
+};  // Ends get_project_name()
+
 /**
  * Ensure all required environment variables exist. Add each missing variable
  *    to an error that will be thrown at the end.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "4.6.1",
+  "version": "4.7.1",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
@@ -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

@@ -4,7 +4,7 @@ Feature: Interactive steps
 # In tag names, 'i' is for 'interactive'
 
 @slow @i1
-Scenario: I set text-type values
+Scenario: I set various values
   Given I start the interview at "all_tests"
   Then the question id should be "upload files"
   When I set the var "upload_files_visible" to "some_png_1.png, some_png_2.png"
@@ -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

package/tests/features/observation_steps.feature

@@ -98,7 +98,7 @@ Scenario: Test "Then I don’t continue" with an apostrophe
   Then I don’t continue
   And I will be told an answer is invalid
 
-@fast @o9 @table
+@fast @o9 @table @json
 Scenario: I can match JSON page var to str
   Given I start the interview at "all_tests.yml"
   And I get to "showifs" with this data:
@@ -123,7 +123,7 @@ Scenario: I get the page's JSON
   Given I start the interview at "all_tests"
   Then I get the page's JSON variables and values
 
-@fast @o11
+@fast @o11 @screenshot
 Scenario: I take a screenshot
   Given I start the interview at "all_tests"
   Then I take a screenshot