@suffolklitlab/alkiln 5.15.0-feat-random-9 → 5.15.1-fix-race-condition

package/.github/workflows/github_server.yml

@@ -160,7 +160,7 @@ jobs:
           #### Developer note: You can probably leave the rest out
           #### To learn more, see https://assemblyline.suffolklitlab.org/docs/alkiln/writing/#optional-inputs
           ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
-          # ALKILN_VERSION: 
+          ALKILN_VERSION: "@race"
 
       #### Developer note: Example of making an issue when tests fail
       #### that includes the text of the failure output file

package/.github/workflows/playground.yml

@@ -82,4 +82,4 @@ jobs:
           # want to check up on this.
           ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
           #### Developer note: You can probably leave this out
-          # ALKILN_VERSION: 
+          ALKILN_VERSION: "@race"

package/CHANGELOG.md

@@ -18,49 +18,36 @@ Security - in case of vulnerabilities.
 Format:
 
 ## [Unreleased]
-
 - 
 
 ## [1.0.0] - 2021-01-16
 ### Added
-
 - 
 
 ### Changed
-
 - 
 
 ### Deprecated
-
 - 
 
 ### Removed
-
 - 
 
 ### Fixed
-
 - 
 
 ### Security
-
 - 
 
 ### Internal
-
 - 
 -->
 
 ## [Unreleased]
 
-### Added
-
-- "Breaking news" feature for ALKilnInThePlayground - a way new ALKiln versions can talk directly with authors even if ALKilnInThePlayground's version stays the same. ALKilnInThePlayground will be able to get text from ALKiln that ALKilnInThePlayground can turn into Mako and then insert on a screen the author can see.
-
-### Changed
-
-- Implement constrained random answers Step for ALKilnInThePlayground.
+### Fixed
 
+- Fixed race condition between navigating and extracting button text.
 
 ## [5.15.1] - 2025-08-05
 

package/lib/run_cucumber.js

@@ -111,8 +111,8 @@ async function main() {
    */
 
   if ( success ) {
-    log.info({ code: `ALK0054`, context: `post_run`, },
-      `Test process exited without error.`
+    log.success({ code: `ALK0054`, context: `post_run`, },
+      `Tests succeeded!`
     );
   } else {
     // Don't want to throw error here, so don't pass error object

package/lib/scope.js

@@ -7,6 +7,7 @@ const { AxePuppeteer } = require('@axe-core/puppeteer');
 const safe_filename = require("sanitize-filename");
 // "en" is faster to import: https://github.com/faker-js/faker/issues/1114#issuecomment-1169532948
 const faker = require('@faker-js/faker/locale/en').faker;
+const { v4: uuidv4 } = require('uuid');
 
 // Ours
 const pdf_reader = require('./utils/pdf_reader');
@@ -254,23 +255,21 @@ module.exports = {
     if ( options.waitForTimeout ) { await time.waitForTimeout( options.waitForTimeout ); }
   },  // Ends afterStep
 
-  tapElementAndNavigate: async function(scope, { elem, waitForTimeout=0 }) {
-    /** Tap a given element, detect navigation, and do appropriate related things.
-     *  TODO: not quite sure if we'll be using `waitForTimeout`. */
+  tapElementAndNavigate: async function(scope, { elem, waitForTimeout=null }) {
+    /** Tap a given element, detect navigation, and do appropriate related things. */
 
     let start_url = await scope.page.url();  // so we can later check for navigation
 
     await scope.tapElementAndStayOnPage(scope, {
       elem,
-      click_promise: Promise.all([
-        scope.page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
-        elem.evaluate( (el) => { return el.click(); })
-      ])
+      promise_returners: [
+        () => { return scope.nav_race(scope, {}).result; },
+        () => { return elem.evaluate( (el) => { return el.click(); }) },
+      ]
     });
 
-    // TODO: Not sure how to detect navigation landing at same page, such as
-    // with a user input validation error. Does that count as navigating?
-    // Maybe url change + trigger var change? Maybe just trigger var?
+    // For other ideas for detecting navigation, see
+    // https://github.com/SuffolkLITLab/ALKiln/issues/229
     let end_url = await scope.page.url();
     let navigated = start_url !== end_url;
 
@@ -282,36 +281,77 @@ module.exports = {
       let { question_has_id, id, id_matches } = await scope.examinePageID( scope, 'none to match' );
 
       // If navigation, wait for 200ms to let things finish loading and moving
-      await scope.afterStep(scope, { waitForTimeout: 200, navigated: true });
+      await scope.afterStep(scope, {
+        waitForTimeout: ( waitForTimeout || 200 ),
+        navigated: true
+      });
     } else {
-      await scope.afterStep(scope, { waitForTimeout, navigated: false });
+      // Discuss: Fail here or later since the test didn't manage to navigate?
+      await scope.afterStep(scope, {
+        waitForTimeout: ( waitForTimeout || 0 ),
+        navigated: false
+      });
     }
   },  // Ends scope.tapElementAndNavigate()
 
-  tapElementAndStayOnPage: async function(scope, { elem, click_promise }) {
+  nav_race: function(scope, opts={}) {
+    /**
+     * Return a Promise for a race that detects which, if any, navigation result
+     * a navigation had.
+     * 
+     * Warning: Unable to effectively add event listener for `daPageLoad`. Gets
+     * overwritten on every page load.
+     * 
+     * @returns
+     *   { obj }
+     *     ok { bool } - True if no unexpected errors
+     *     messages {[ str ]} - Any error or info messages
+     *     errors {[ Error ]} - Any Errors that happened
+     *     result { Promise } with result of { obj } - HTTP response or other data
+     *     aborters {[ obj ]} - Abort signals for all the Promises involved
+     * */
+    let ok, messages, errors;
+    let aborters = [];
+
+    let result = Promise.race([
+      scope.page.waitForNavigation({ waitUntil: 'domcontentloaded' }),
+    ]);
+
+    return { result, aborters, ok, messages, errors, };
+  },  // Ends scope.nav_race()
+
+  tapElementAndStayOnPage: async function(scope, { elem, promise_returners=null }) {
     /** Tap a given element, detect navigation, and do appropriate related things.
-    *  `click_promise can be any kind of Promise, including a Promise.all()
+     * 
+     * @param elem { obj } - element to tap
+     * @param promise_returners {[ func -> Promise ]} - list of functions that
+     *     return promises
     */
     await scope.guard_against_missing_tap_element(scope, { elem });
 
     // Get the text on the button or link for a potential error message later
     let tapperText = await (await elem.getProperty('textContent')).jsonValue();
 
-    click_promise = click_promise || elem.click();
+    let click_promises = null;
+    if ( promise_returners ) {
+      click_promises = Promise.all(promise_returners.map( pr_ret => pr_ret() ));
+    } else {
+      click_promises = elem.click();
+    }
     
     // TODO: implement and use scope.handle_possible_timeout()
     try {
-      // Serever error loads page, so keeping things shorter by not looking
+      // Server error loads page, so keeping things shorter by not looking
       // for that text too. Also, puppeteer will ensure proper timeout.
       await Promise.race([
-        click_promise,
+        click_promises,
         // This is meant to detect user-visible alerts/errors,
         // not breaking errors in the testing code.
+        // No need for aborters since puppeteer has its own timeout
         scope.page.waitForSelector('.alert-danger', { visible: true }),
         scope.page.waitForSelector('.da-has-error', { visible: true }),
       ]);
     } catch ( error ) {
-
       if ( error.name === `TimeoutError` ) {
         let non_reload_report_msg = `After ALKiln tapped "${ tapperText }" it took too long to load the next page.`;
         await scope.handle_page_timeout_error( scope, { non_reload_report_data: {
@@ -2729,7 +2769,7 @@ module.exports = {
         pic_name = `pic_on-${ short_id }-${ timestamp }`;
       }
 
-      await scope.take_a_screenshot( scope, { path: `${ scope.paths.scenario }/${ pic_name }.jpg` });
+      await scope.take_a_screenshot( scope, { path: `./${ scope.paths.scenario }/${ pic_name }.jpg` });
 
       await scope.afterStep( scope );
     },  // Ends scope.steps.screenshot()

package/lib/setup/TestGenerator.js

@@ -15,13 +15,11 @@ const get_error_stacks = require(`../utils/get_error_stacks`);
  *     file incorrectly.
  * Discuss: Require author to use "Template Scenario:" as they keyword (Also
  *     "Template Scenario Outline:") (or "Scenario Template", maybe harder to
- *     scan) for 2 reasons. 1. Gets the vocab of "generator" in early (though
+ *     scan) for 2 reasons. 1. Gets the vocab of "template" in early (though
  *     that doesn't match "constraints" Step, which is a whole other language
- *     problem we haven't solved yet.) 2. Saying
- *     "ALKILN_MAX_RANDOM_TESTS_PER_SCENARIO" is confusing when "Scenario" means
- *     different things - a generator Scenario and a regular Scenario. Also,
- *     "ALKILN_MAX_RANDOM**IZED**_TESTS_PER_SCENARIO" might be more accurate. Is
- *     "ALKILN_MAX_TESTS_PER_GENERATOR" better?
+ *     problem we haven't solved yet.) 2. Saying "ALKILN_MAX_RANDOM_TESTS_PER_SCENARIO"
+ *     is confusing when "Scenario" means different things - a template
+ *     Scenario and a regular Scenario.
  * Discuss: Now that Log is less fragile and duplicated, shall we create a new
  *     Log instance in here?
  * Discuss: consider debug types that are for authors. Sort of like warnings,
@@ -103,13 +101,13 @@ module.exports = class TestGenerator {
       }
     }
 
-    log.debug({ code: `ALK0267`, context: `generating files`, }, `Constrained random answers tests:\n`, new_files_strings );
+    log.debug({ code: `ALK0267`, context: `generating files`, }, `Constrained random answers tests:`, new_files_strings );
 
     let tests_path = `${ sources_path }/${ FOLDER_NAME }`;
     let artifacts_path = `${ session_vars.get_artifacts_path_name() }/${ FOLDER_NAME }`;
     save_files({ tests_path, artifacts_path, file_strings: new_files_strings });
 
-    log.debug({ code: `ALK0271`, context: `generating files`, }, `Tried to save generated files to ${ artifacts_path }` );
+    log.info({ code: `ALK0271`, context: `generating files`, }, `Tried to save generated files to ${ artifacts_path }` );
 
     return { new_strings: new_files_strings, errors: all_errors };
   }
@@ -181,7 +179,7 @@ module.exports = class TestGenerator {
     let scenario_objs = doc_AST.feature.children;
     if ( !scenario_objs[0] ) {
       let syntax_error = log.error({ code: `ALK0235`, context: `generating files`, before: `\n\n`, },
-        `It looks like the author's generator .feature file at "${ generator_path }" has 0 Scenarios.`
+        `It looks like the author's template .feature file at "${ generator_path }" has 0 Scenarios.`
       );
       return { new_contents: null, errors: [new Error( syntax_error )]};
     }
@@ -189,7 +187,7 @@ module.exports = class TestGenerator {
 
     if ( scenario_objs.length > 1 ) {
       let too_many_scenarios = log.error({ code: `ALK0236`, context: `generating files`, },
-        `A generator file can only have 1 generator Scenario. This one has ${ scenario_objs.length }.`
+        `A template file can only have 1 template Scenario. This one has ${ scenario_objs.length }.`
       );
       return { new_contents: ``, errors: [new Error( too_many_scenarios )] };
     }
@@ -200,14 +198,14 @@ module.exports = class TestGenerator {
 
     let feature_text = get_Feature_text({ feature: doc_AST.feature, generator_lines });
 
-    // One string for each generator Scenario
-    let { scenarios_strings, total_Scenarios_made, errors: scenarios_errors } = this.get_new_Scenarios_strs({
+    let { scenarios_strings, errors: scenarios_errors } = this.get_new_Scenarios_strs({
       scenario_objs,
       generator_lines
     });
     generation_errors.push( ...scenarios_errors );
 
-    let count_msg = `ALKiln generated ${ total_Scenarios_made } Scenario or Scenarios`;
+
+    let count_msg = `ALKiln generated ${ scenarios_strings.length } Scenario or Scenarios`;
 
     if ( scenarios_strings.length === 0 ) {
       let error = log.error({ code: `ALK0263`, context: `generating files`, }, count_msg );
@@ -233,7 +231,7 @@ module.exports = class TestGenerator {
 
   get_new_Scenarios_strs({ scenario_objs, generator_lines }) {
     /** Return all the strings of the generated Scenarios and any Errors we ran
-     *     into. Each generator Scenario gets one string of all its Scenarios.
+     *     into.
      * 
      * @param {object} obj - Named arguments
      * @param {object} obj.scenario_objs - 0 or more Gherkin Scenario objects
@@ -254,8 +252,7 @@ module.exports = class TestGenerator {
     let errs_n_warns = new Misbehaviors();
 
     let strs_for_all_new_Scenarios = [];
-    let total_Scenarios_made = 0;
-    // Soon we want to be able to handle multiple generator Scenarios per file
+    // Soon we want to be able to handle multiple template Scenarios per file
     for ( let scenario_obj_i = 0; scenario_obj_i < scenario_objs.length; scenario_obj_i++ ) {
 
       errs_n_warns.reset_warnings();
@@ -275,7 +272,7 @@ module.exports = class TestGenerator {
       );
       if ( errs_n_warns.errors.length > 0 ) { continue; }
 
-      let { new_Scenarios_text, num_made } = errs_n_warns.add(
+      let { new_Scenarios_text } = errs_n_warns.add(
         this.get_1_text_block_of_all_new_Scenarios_from_1_generator_Scenario({
           scenario: generator_Scenario,
           generator_lines: generator_lines,
@@ -284,7 +281,6 @@ module.exports = class TestGenerator {
         })
       );
       if ( errs_n_warns.errors.length > 0 ) { continue; }
-      total_Scenarios_made += num_made;
 
       if ( errs_n_warns.warnings.length > 0 ) {
         new_Scenarios_text = add_warnings_Scenario({
@@ -296,7 +292,7 @@ module.exports = class TestGenerator {
       strs_for_all_new_Scenarios.push( new_Scenarios_text );
     }  // ends for every scenario_container
 
-    return { scenarios_strings: strs_for_all_new_Scenarios, total_Scenarios_made, ...errs_n_warns };
+    return { scenarios_strings: strs_for_all_new_Scenarios, ...errs_n_warns };
   }
 
 
@@ -376,32 +372,22 @@ module.exports = class TestGenerator {
 
     let got_fewer_tests_than_desired = new_test_bodies.length < num_to_make;
     if ( got_fewer_tests_than_desired ) {
-      let fewer_test_msg = `ALKiln tried a bunch of times, but it could only`
-      + ` make ${ new_test_bodies.length } *unique* tests out of the`
-      + ` ${ num_to_make } the author wanted for this Scenario. This probably`
-      + ` happened because ALKiln makes sure every test is unique^1. Maybe`
-      + ` there were too few combinations for ALKiln to use. The Scenario:`
-      + `\n      ${ scenario_description_for_logs({ scenario }) }`
-      + `\n\n[^1]: "Unique tests" are only unique from the other tests ALKiln`
-      + ` is generating *right now*. ALKiln doesn't check your regular tests.`;
-
-      let warn_too_few = log.warn({ code: `ALK0260`, context: `generating files generator-scenario-level`, },
-        fewer_test_msg,
+      let warn_too_few = log.warn({ code: `ALK0260`, context: `generating files template-scenario-level`, },
+        `ALKiln could only make ${ new_test_bodies.length } *unique* tests out of the ${ num_to_make } the author wanted for this Scenario. Note that ALKiln compares all generated Scenarios with each other to make sure all are unique. This Scenario may be a duplicate of a Scenario generated from a previous template. The Scenario:\n      ${ scenario_description_for_logs({ scenario }) }`,
       )
       // Discuss: Should we add more structure to Misbehaviors to give them
-      //     context levels (Feature, generator Scenario, generated Scenario)
+      //     context levels (Feature, template Scenario, generated Scenario)
       misfits.add({ warnings: [ warn_too_few ] });
     }
 
     let new_Scenarios_text = new_test_bodies.join(`\n\n`);
-    let num_made = new_test_bodies.length;
     new_Scenarios_text = add_total_tests({
-      scenario_group_str: new_Scenarios_text, num_tests: num_made
+      scenario_group_str: new_Scenarios_text, num_tests: new_test_bodies.length
     });
 
     log.debug({ code: `ALK0261`, context: `generating files`, }, `new_Scenarios_text before adding warnings:\n`, new_Scenarios_text );
 
-    return { new_Scenarios_text, num_made, ...misfits };
+    return { new_Scenarios_text, ...misfits };
   }
 
   try_to_get_one_unique_middle({
@@ -509,7 +495,7 @@ function get_generator_AST({ file_text, generator_path }) {
 
   if ( generator_errors.length > 0 ) {
     let syntax_error = log.error({ code: `ALK0232`, context: `generating files`, before: `\n\n`, },
-      `The author's generator .feature file at "${ generator_path }" has Gherkin syntax error(s). You might see more warnings above or below this one.\n`,
+      `The author's template .feature file at "${ generator_path }" has Gherkin syntax error(s). You might see more warnings above or below this one.\n`,
       ...get_error_stacks({ errors: generator_errors })
     );
     return { doc_AST: null, errors: [new Error( syntax_error )] };
@@ -519,14 +505,14 @@ function get_generator_AST({ file_text, generator_path }) {
 
   if ( !doc_AST.feature ) {
     let feature_error = log.error({ code: `ALK0233`, context: `generating files`, before: `\n\n`, },
-      `The author's generator .feature file at "${ generator_path }" needs to include the \`Feature\` keyword.`
+      `The author's template .feature file at "${ generator_path }" needs to include the \`Feature\` keyword.`
     );
     return { doc_AST: null, errors: [new Error( feature_error )] };
   }
 
   // Should not get here
   let unknown_error = log.error({ code: `ALK0234`, context: `generating files`, before: `\n\n`, },
-    `The author's generator .feature file at "${ generator_path }" ran into an unanticipated error when ALKiln tried to parse it. If you have a moment, we would love for you to send us your debug.txt.`
+    `The author's template .feature file at "${ generator_path }" ran into an unanticipated error when ALKiln tried to parse it. If you have a moment, we would love for you to send us your debug.txt.`
   );
   return { doc_AST, errors: [new Error( unknown_error )] };
 }
@@ -673,7 +659,7 @@ function get_fore_Steps({ scenario }) {
   if ( there_were_no_fore_Steps ) {
     misfits.add({ errors: [
       new Error( log.error({ code: `ALK0242`, context: `generating files`, },
-        `A generator Scenario's first Step must say how many constrained random answers tests to make. The generator Scenario on line ${ scenario.location.line } is missing that Step. The Scenario's description is:\n${ description }`
+        `A template Scenario's first Step must say how many constrained random answers tests to make. The template Scenario on line ${ scenario.location.line } is missing that Step. The Scenario's description is:\n${ description }`
       ) )
     ] });
   } else {
@@ -740,7 +726,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
     //     a way that is also maintainable?
     warnings.push( 
       log.warn({ code: `ALK0238`, context: `generating files`, },
-        `A generator Scenario has too many Steps that set the number of tests to make. ALKiln will use the final number Step it finds or calculates. The current Step:\n      ${ text }`
+        `A template Scenario has too many Steps that set the number of tests to make. ALKiln will use the final number Step it finds or calculates. The current Step:\n      ${ text }`
       )
     );
   }
@@ -751,7 +737,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
   if ( number_matcher === null ) {
     warnings.push( 
       log.warn({ code: `ALK0239`, context: `generating files`, },
-        `A generator Scenario is missing the number of tests to make. ALKiln will now make 1 constrained random answers test. The current Step:\n      ${ text }`
+        `A template Scenario is missing the number of tests to make. ALKiln will now make 1 constrained random answers test. The current Step:\n      ${ text }`
       )
     );
     return { num_to_make: 1, warnings, errors };
@@ -1115,7 +1101,7 @@ function get_final_ids({ step_text }) {
   let ids = step_text.match( CAPTURE_QUESTION_IDS_REGEX );
 
   if ( ids === null ) {
-    let missing_ids_msg = `The constrained random answers Step is missing its question ids. ALKiln is unable to create random tests for this generator Scenario. The Step:\n${ step_text }`;
+    let missing_ids_msg = `The constrained random answers Step is missing its question ids. ALKiln is unable to create random tests for this template Scenario. The Step:\n${ step_text }`;
     let error = log.error({ code: `ALK0250`, context: `generating files`, }, missing_ids_msg );
     errors.push(new Error( error ));
   }
@@ -1364,7 +1350,7 @@ function remove_warning_tag_placeholder({ new_text }) {
 
 
 function add_total_tests({ scenario_group_str, num_tests }) {
-  /** Paste in the total number of tests generated for this generator Scenario.
+  /** Paste in the total number of tests generated for this template Scenario.
    * 
    * @param {object} obj - Named arguments
    * @param {str} obj.scenario_group_str - The combined string of all the
@@ -1385,10 +1371,10 @@ function add_warnings_Scenario({ scenarios_str, warnings }) {
    *     Scenarios. Basically, a whole-generator-scope warning.
    * 
    * Discuss: Add a pre-group Scenario for every group of generated Scenarios
-   *     identifying the generator Scenario of the subsequent new Scenarios.
+   *     identifying the template Scenario of the subsequent new Scenarios.
    *     That is, even when there is no warning to give.
    * 
-   * TODO: If/when we allow multiple generator Scenarios, use the ID here too
+   * TODO: If/when we allow multiple template Scenarios, use the ID here too
    * 
    * @param {object} obj - Named arguments
    * @param {str} obj.scenarios_str - The str of the already existing Scenarios
@@ -1517,7 +1503,7 @@ function save_files({ tests_path, artifacts_path, file_strings }) {
   fs.mkdirSync( artifacts_path, { recursive: true });
 
   log.debug({ code: `ALK0269`, context: `generating files`, },
-    `Saving ${ file_strings.length } newly generated files in "${ tests_path }" and "${ artifacts_path }"`
+    `Saving ${ file_strings.length } newly generated files in "${ tests_path }"`
   );
 
   let count = 1;
@@ -1529,8 +1515,8 @@ function save_files({ tests_path, artifacts_path, file_strings }) {
     fs.appendFileSync( `${ artifacts_path }/${ filename }`, file_str );
   }
 
-  log.info({ code: `ALK0270`, context: `generating files`, },
-    `Saved new generated files in "${ artifacts_path }"`
+  log.debug({ code: `ALK0270`, context: `generating files`, },
+    `Saved new generated files:`, fs.readdirSync( tests_path )
   );
 }
 

package/lib/setup/artifacts.js

@@ -2,7 +2,7 @@
 
 const session_vars = require(`../utils/session_vars`);
 const files = require(`../utils/files`);
-const Log = require(`../utils/Log.js`);
+const Log = require(`../setup/artifacts.js`);
 
 /** Reset and refresh artifacts path name */
 
@@ -12,15 +12,9 @@ session_vars.delete_artifacts_path_name();
 // If using `npm run cucumber` (as opposed to the bin commands),
 // use `--` before `--sources=./foo`
 const argv = require(`minimist`)( process.argv.slice(2) );
-
-const artifacts_path = files.make_artifacts_folder();
+const artifacts_path = files.make_artifacts_folder( argv.path );
 
 session_vars.save_artifacts_path_name( artifacts_path );
 
-const log = new Log({ path: artifacts_path, context: `artifacts` });
-log.info({ code: `ALK0284`, context: `artifacts`,},
-  `Created the artifacts folder at "${ artifacts_path }"`
-);
-
-// This is just for artifacts, not any other config values. Leave the config
-// Project name value as it is. Local developers find it useful to re-use it.
+// Leave the config Project name value as it is. Local developers find it
+//    useful to re-use that value.

package/lib/setup/validate.js

@@ -32,6 +32,7 @@ function validate_Gherkin_files() {
    *    generator files. If there are any, it logs those errors and then finally
    *    throws an error. Uses the values in command line arguments.
    * */
+
   let sources_paths = set_sources_paths({ log });
 
   let all_errors = [];
@@ -43,16 +44,10 @@ function validate_Gherkin_files() {
   // Discuss: If an author has only some files with syntax errors, should we try
   //    to still run the tests for the files that had valid syntax?
   if ( all_errors.length > 0 ) {
-    let parse_error_msg = `ALKiln ran into Gherkin syntax error(s) when parsing `
-      + `these test feature files. See warnings and errors above.`
     log.throw({ code: `ALK0230`, context: `validating files`,
-      error: new Error( parse_error_msg )
+      error: new Error( `ALKiln ran into Gherkin syntax error(s) when parsing your test feature files. See warnings and errors above.` )
     });
   };
-
-  log.info({ code: `ALK0283`, context: `validating files`,},
-    `Validated all feature files`
-  );
 }
 
 
@@ -69,23 +64,15 @@ function parse_all_feature_files_in({ sources_path }) {
    * */
   let all_AST_errors = [];
 
-  let feature_file_paths = null;
-  try {
-    feature_file_paths = fast_glob.sync(
-      `${ sources_path }/**/*.feature`,
-      // These files were generated last time and will get deleted before the run
-      { ignore: [`${ sources_path }/${ globals.generated_files_folder_name }/*`] }
-    );
-  } catch ( feature_paths_error ) {
-    log.error({ code: `ALK0282`, context: `validating files`, },
-      `Error while trying to find feature files at "${ sources_path }"`,
-      feature_paths_error
-    );
-    return { errors: [ feature_paths_error ]};
-  }
+  let feature_file_paths = fast_glob.sync(
+    `${ sources_path }/**/*.feature`,
+    // These files were generated last time and will get deleted before the run
+    { ignore: [`${ sources_path }/${ globals.generated_files_folder_name }/*`] }
+  );
 
   for ( let feature_path of feature_file_paths ) {
-    let file_text = fs.readFileSync( feature_path, { encoding: `utf8` } );
+
+    let file_text = fs.readFileSync( feature_path, { encoding: `utf8` });
     let { AST, errors: these_AST_errors } = get_Gherkin_AST({ file_text });
 
     if ( these_AST_errors.length > 0 ) {

package/lib/steps.js

@@ -25,9 +25,6 @@ const session_vars = require('./utils/session_vars');
 const files = require('./utils/files' );
 const reports = require(`./utils/reports`);
 const da_api = require('./docassemble/docassemble_api_interface');
-const globals = require(`./globals`);
-
-const GENERATED_FILES_FOLDER_NAME = globals.generated_files_folder_name;
 
 /* Of Note:
 - We're using `*=` for selectors because sometimes da text has funny characters in it that are hard to anticipate
@@ -121,9 +118,6 @@ Before(async (scenario) => {
 
   // Start the running "progress bar" for the Scenario
   log.stdout({}, `\nScenario: ${ scenario.pickle.name }: `);
-  // Save Scenario data in Scenario folder
-  // '@alkiln @generated'
-  // console.log( JSON.stringify( scenario ) );
 
   // Create browser, which can't be created in BeforeAll() where .driver doesn't exist for some reason
   if (!scope.browser) {
@@ -161,16 +155,6 @@ Before(async (scenario) => {
   fs.mkdirSync( scope.paths.scenario );
   // Store path name for this Scenario's individualized report
   scope.paths.scenario_report = `${ scope.paths.scenario }/report.txt`;
-  // If it's a generated Scenario, save the `.feature` file in here
-  // GENERATED_FILES_FOLDER_NAME
-  if ( scenario.gherkinDocument.uri.includes("_alkiln_generated") ) {
-    try {
-      let file_text = fs.readFileSync( scenario.gherkinDocument.uri, {encoding: `utf8`});
-      fs.appendFileSync( `${ scope.paths.scenario }/${ filename }`, file_text );
-    } catch ( saving_feat_file_error ) {
-      // Ignore. This is not crucial.
-    }
-  }
 
   // Downloads
   scope.downloadComplete = false;

package/lib/utils/Log.js

@@ -228,7 +228,6 @@ class Log {
       }
 
       if ( !fs.existsSync( dir )) {
-        process.stdout.write(`Making artifacts folder in Log at ${ dir }`)
         files.make_artifacts_folder( dir );
       }
 

package/lib/utils/files.js

@@ -1,6 +1,5 @@
 const fs = require('fs');
 const safe_filename = require('sanitize-filename');
-const path = require(`path`);
 
 let files = {};
 
@@ -22,30 +21,27 @@ files.readable_date = function() {
   return fancy_str;
 };  // Ends files.readable_date()
 
-files.make_artifacts_folder = function ( file_path ) {
+files.make_artifacts_folder = function (path) {
   /** Makes a folder in the root of the project if it doesn't
    *  already exist, either with the given name or with a default name.
    *
    * Works for local development as well, without action.yml or workflow files.
    * */
-  if (file_path) {
-    let name_parts = file_path.split(`/`);
+  if (path) {
+    let name_parts = path.split(`/`);
     let safe_parts = [];
     for ( let part of name_parts ) {
       safe_parts.push(safe_filename( part ));
     }
-    file_path = path.join( ...safe_parts );
+    path = safe_parts.join(`/`);
   } else {
-    file_path = `alkiln-${ files.readable_date() }`
+    path = `alkiln-${ files.readable_date() }`
   }
 
-  const root = process.cwd();
-  root_path = path.join( root, file_path );
-
   // `recursive` avoids errors if folder already exists
   // https://nodejs.org/docs/latest-v18.x/api/fs.html#fspromisesmkdirpath-options
-  fs.mkdirSync( root_path, { recursive: true });
-  return root_path;
+  fs.mkdirSync( path, { recursive: true });
+  return path;
 };  // Ends files.make_artifacts_folder()
 
 module.exports = files;