@suffolklitlab/alkiln 4.6.0 → 4.7.0

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
@@ -430,7 +458,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 );
@@ -650,7 +678,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 +686,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 +763,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 +780,107 @@ 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
+  */
+  scope.paths.random_screenshots = `${ scope.paths.scenario }/random_answers_screenshots`;
+  fs.mkdirSync( scope.paths.random_screenshots );
+
+  // 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
+  // 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` );
+
+    // 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 );
+
+      }, 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 }/${ 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
+          }
+
+          if ( buttons_exist ) {
+            process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
+          }         
+
+          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 );
+
+        } 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 +894,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
   );
 });
@@ -935,8 +1060,22 @@ After(async function(scenario) {
         });
       } 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
 
@@ -991,6 +1130,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 +1146,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,32 @@
+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' });
+  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.0",
+  "version": "4.7.0",
   "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"
@@ -87,6 +87,10 @@ Scenario: I set text-type values
   Then the question id should be "button event action"
   And I tap to continue
   # Next page
+  Then the question id should be "single-dropdown-field"
+  And I set the var "single_dropdown_field" to "email"
+  And I tap to continue
+  # Next page
   Then the question id should be "the end"
 
 @fast @i2 @secret
@@ -127,4 +131,9 @@ 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
+
+@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/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

package/tests/features/random_input.feature

@@ -0,0 +1,15 @@
+@random_input
+Feature: Assembly Line package-specific Steps
+
+# In tag names, 'ri' is for 'random input'
+
+@slow @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
+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

package/tests/features/story_tables.feature

@@ -68,6 +68,7 @@ Covers story table tests for:
     | signature_1 |  |  |
     | signature_2 |  |  |
     | single_quote_dict['single_quote_key']['sq_two'] | true |  |
+    | single_dropdown_field | email | |
     | x[i].name.first | Proxyname1 | proxy_list[0].name.first |
     | x[i].name.first | Proxyname2 | proxy_list[1].name.first |
     | x.target_number | 2 | proxy_list.target_number |

package/tests/unit_tests/getSafeScenarioBaseFilename.fixtures.js

@@ -1,8 +1,6 @@
 let names = {};
 
 names.with_spaces = `a tests description`;
-names.tag1 = `tag1`;
-names.tag2 = `tag2`;
 
 names.non_english_chars = `是汉字`;
 

package/tests/unit_tests/getSafeScenarioBaseFilename.test.js

@@ -6,14 +6,11 @@ const scope = require(`../../lib/scope.js`);
 const getSafeScenarioBaseFilename = scope.getSafeScenarioBaseFilename;
 
 
-let mock_scenario = function ( description, tag_names=[] ) {
+let mock_scenario = function ( description ) {
   /** Mock the complex structure of a Scenario object */
   let scenario = {
-    pickle: { name: description, tags: [], }
+    pickle: { name: description }
   };
-  for ( let tag of tag_names ) {
-    scenario.pickle.tags.push({ name: tag });
-  }
   return scenario;
 };  // Ends mock_scenario();
 
@@ -23,39 +20,31 @@ describe(`When I use scope.getSafeScenarioBaseFilename()`, function() {
     scope.language = undefined;
   });
 
-  // No language, no tags
+  // No language
   it(`preserves spaces`, async function() {
-    let scenario = mock_scenario( names.with_spaces, [] );
+    let scenario = mock_scenario( names.with_spaces );
     let result = await getSafeScenarioBaseFilename( scope, { scenario });
     expect( result ).to.equal( names.with_spaces );
   });
 
   it(`preserves non-english characters`, async function() {
-    let scenario = mock_scenario( names.non_english_chars, [] );
+    let scenario = mock_scenario( names.non_english_chars );
     let result = await getSafeScenarioBaseFilename( scope, { scenario });
     expect( result ).to.equal( names.non_english_chars );
   });
 
   it(`replaces invalid characters with "_"`, async function() {
-    let scenario = mock_scenario( names.colon_input, [] );
+    let scenario = mock_scenario( names.colon_input );
     let result = await getSafeScenarioBaseFilename( scope, { scenario });
     expect( result ).to.equal( names.colon_output );
   });
 
-  // language, 1 tag
-  it(`adds a language and 1 tag correctly, preserving numbers`, async function() {
+  // language
+  it(`adds a language correctly to a description`, async function() {
     scope.language = names.non_english_chars;
-    let scenario = mock_scenario( names.with_spaces, [ names.tag1 ] );
+    let scenario = mock_scenario( names.with_spaces );
     let result = await getSafeScenarioBaseFilename( scope, { scenario });
-    let expected = `${ names.non_english_chars }-${ names.with_spaces }-${ names.tag1 }`;
-    expect( result ).to.equal( expected );
-  });
-
-  // 2 tags
-  it(`adds 2 tags correctly, preserving numbers`, async function() {
-    let scenario = mock_scenario( names.with_spaces, [ names.tag1, names.tag2 ] );
-    let result = await getSafeScenarioBaseFilename( scope, { scenario });
-    let expected = `${ names.with_spaces }-${ names.tag1 }-${ names.tag2 }`;
+    let expected = `${ names.non_english_chars }-${ names.with_spaces }`;
     expect( result ).to.equal( expected );
   });
 

package/tests/unit_tests/getSafeScenarioFilename.test.js

@@ -8,9 +8,12 @@
  
  
 let test_filename = function ( expected_prefix, result ) {
-   /* Test a name to see if it's valid output with a language defined. */
-  let expected_name_regex_str = `^${ expected_prefix }\\d{13}-${ names.base_filename }$`;
-   let regex = new RegExp( expected_name_regex_str );
+  /* Test a name to see if it's valid output with a language defined. */
+  let expected_name_regex_str = `^${ expected_prefix }-${ names.base_filename }-\.{37}$`;
+  if ( expected_prefix == `` ) {
+   expected_name_regex_str = `^${ names.base_filename }-\.{37}$`;
+  }
+  let regex = new RegExp( expected_name_regex_str );
  
   // Log more info if it failed
   let found_match = regex.test( result );