@suffolklitlab/alkiln 5.13.3-feat-random → 5.13.3-feat-random-2

package/lib/setup/TestGenerator.js

@@ -11,6 +11,9 @@ const get_error_stacks = require(`../utils/get_error_stacks`);
  *     severe warnings (like "will skip the random test") vs. slight warnings
  *     (like "missing number in constraints random test")
  * TODO: Post-MVP, don't repeat tests that the author has already created
+ * TODO: Post-MVP, write Steps that warn about fore-Steps and constraints Steps
+ *     when they appear in a regular test. It probably means someone named the
+ *     file incorrectly.
  * Discuss: Require author to use "Generator Scenario:" as they keyword (Also
  *     "Generator Scenario Outline:") (or "Scenario Generator", maybe harder to
  *     scan) for 2 reasons. 1. Gets the vocab of "generator" in early (though
@@ -96,13 +99,13 @@ module.exports = class TestGenerator {
       }
     }
 
-    log.debug({ code: `ALK0265`, context: `generating files`, }, `Constrained random answers tests:`, 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.info({ code: `ALK0269`, 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 };
   }
@@ -140,7 +143,7 @@ module.exports = class TestGenerator {
 
     let { errors: generated_parsing_errors } = validate_syntax({ file_text: new_contents, generator_path });
     if ( generated_parsing_errors.length > 0 ) {
-      let syntax_error = log.error({ code: `ALK0264`, context: `generating files`, before: `\n\n`, },
+      let syntax_error = log.error({ code: `ALK0266`, context: `generating files`, before: `\n\n`, },
         `The .feature file ALKiln generated from "${ generator_path }" had Gherkin syntax error(s) ALKiln did not anticipate. If you have a moment, we would love you to send us your debug.txt.\n`,
         ...get_error_stacks({ errors: generated_parsing_errors })
       );
@@ -180,6 +183,12 @@ module.exports = class TestGenerator {
     }
     // `scenario_objs[0].scenario` seems to always be defined by here
 
+    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 }.`
+      );
+      return { new_contents: ``, errors: [new Error( too_many_scenarios )] };
+    }
 
     let generation_errors = [];
 
@@ -197,12 +206,12 @@ module.exports = class TestGenerator {
     let count_msg = `ALKiln generated ${ scenarios_strings.length } Scenario or Scenarios`;
 
     if ( scenarios_strings.length === 0 ) {
-      let error = log.error({ code: `ALK0261`, context: `generating files`, }, count_msg );
+      let error = log.error({ code: `ALK0263`, context: `generating files`, }, count_msg );
       generation_errors.push( new Error( error ));
       return { new_contents: null, errors: generation_errors };
     }
 
-    log.info({ code: `ALK0262`, context: `generating files`, }, count_msg );
+    log.info({ code: `ALK0264`, context: `generating files`, }, count_msg );
 
     let scenarios_combined = scenarios_strings.join(`\n\n`);
     let new_file_contents = [ feature_text, scenarios_combined ].join(`\n`);
@@ -210,7 +219,7 @@ module.exports = class TestGenerator {
     if ( !new_file_contents ) {
       // Fallback. Haven't been able to trigger this
      let msg = `Unable to generate a constrained random answers file from "${ generator_path }". See above for warnings and errors.`;
-     let error = log.error({ code: `ALK0263`, context: `generating files`, }, msg );
+     let error = log.error({ code: `ALK0265`, context: `generating files`, }, msg );
      return { new_contents: null, errors: [ new Error( error )] }; 
     }
 
@@ -241,6 +250,7 @@ module.exports = class TestGenerator {
     let errs_n_warns = new Misbehaviors();
 
     let strs_for_all_new_Scenarios = [];
+    // Soon we want to be able to handle multiple generator Scenarios per file
     for ( let scenario_obj_i = 0; scenario_obj_i < scenario_objs.length; scenario_obj_i++ ) {
 
       errs_n_warns.reset_warnings();
@@ -248,7 +258,7 @@ module.exports = class TestGenerator {
       let generator_Scenario = scenario_objs[ scenario_obj_i ].scenario;
 
       let description = scenario_description_for_logs({ scenario: generator_Scenario });
-      log.info({ code: `ALK0236`, context: `generating files`, },
+      log.info({ code: `ALK0237`, context: `generating files`, },
         `Generating files for Scenario at ${ description }`
       );
 
@@ -275,7 +285,7 @@ module.exports = class TestGenerator {
           scenarios_str: new_Scenarios_text, warnings: errs_n_warns.warnings
         });
       }
-      log.debug({ code: `ALK0260`, context: `generating files`, }, `new_Scenarios_text WITH warnings:\n`, new_Scenarios_text );
+      log.debug({ code: `ALK0262`, context: `generating files`, }, `new_Scenarios_text with ${ errs_n_warns.warnings.length } warnings:\n`, new_Scenarios_text );
 
       strs_for_all_new_Scenarios.push( new_Scenarios_text );
     }  // ends for every scenario_container
@@ -360,8 +370,8 @@ module.exports = class TestGenerator {
 
     let got_fewer_tests_than_desired = new_test_bodies.length < num_to_make;
     if ( got_fewer_tests_than_desired ) {
-      let warn_too_few = log.warn({ code: `ALK0258`, context: `generating files generator-scenario-level`, },
-        `ALKiln could only make ${ new_test_bodies.length } unique tests out of the ${ num_to_make } the author wanted for this Scenario:\n      ${ scenario_description_for_logs({ scenario }) }`,
+      let warn_too_few = log.warn({ code: `ALK0260`, context: `generating files generator-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 by a previous generator. 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)
@@ -373,7 +383,7 @@ module.exports = class TestGenerator {
       scenario_group_str: new_Scenarios_text, num_tests: new_test_bodies.length
     });
 
-    log.debug({ code: `ALK0259`, context: `generating files`, }, `new_Scenarios_text without warnings:\n`, new_Scenarios_text );
+    log.debug({ code: `ALK0261`, context: `generating files`, }, `new_Scenarios_text before adding warnings:\n`, new_Scenarios_text );
 
     return { new_Scenarios_text, ...misfits };
   }
@@ -400,7 +410,7 @@ module.exports = class TestGenerator {
      * */
     let misfits = new Misbehaviors();
 
-    log.debug({ code: `ALK0248`, context: `generating files`, }, `Trying to get unique middle` );
+    log.debug({ code: `ALK0249`, context: `generating files`, }, `Trying to get unique middle` );
 
     let keyword_index = get_keyword_index({ scenario });
 
@@ -436,17 +446,17 @@ module.exports = class TestGenerator {
       }
 
       let one_test_body = attempt_lines.join(`\n`);
-      log.debug({ code: `ALK0255`, context: `generating files` }, `Generated test:\n${ one_test_body }` );
+      log.debug({ code: `ALK0257`, context: `generating files` }, `Generated test:\n${ one_test_body }` );
 
       let is_duplicate = this.all_Scenarios_bodies_map[ one_test_body ];
       if ( is_duplicate ) {
-        log.debug({ code: `ALK0256`, context: `generating files` }, `Test is a duplicate on attempt ${ attempts.count }.` );
+        log.debug({ code: `ALK0258`, context: `generating files` }, `Test is a duplicate on attempt ${ attempts.count }.` );
         if ( attempts.count >= attempts.max ) { clear_inner_state(); }
         continue;
       }
 
       // Otherwise, add to the global map and finish
-      log.debug({ code: `ALK0257`, context: `generating files` }, `This test is unique on attempt number ${ attempts.count }.` );
+      log.debug({ code: `ALK0259`, context: `generating files` }, `This test is unique on attempt number ${ attempts.count }.` );
       is_unique = true;
       this.all_Scenarios_bodies_map[ one_test_body ] = true;
 
@@ -646,18 +656,18 @@ function get_fore_Steps({ scenario }) {
   let description = scenario_description_for_logs({ scenario });
   if ( there_were_no_fore_Steps ) {
     misfits.add({ errors: [
-      new Error( log.error({ code: `ALK0241`, context: `generating files`, },
+      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 }`
       ) )
     ] });
   } else {
-    log.debug({ code: `ALK0242`, context: `generating files` },
+    log.debug({ code: `ALK0243`, context: `generating files` },
       `The final "first Step" Gherkin index was ${ last_valid_fore_step_index }. The final file index of that Step was ${ as_index(steps[ last_valid_fore_step_index ].location.line) }. The Scenario description:\n${ description }`
     );
   }
 
   if ( first_vals.num_to_make ) {
-    log.debug({ code: `ALK0243`, context: `generating files` },
+    log.debug({ code: `ALK0244`, context: `generating files` },
       `Will try to make ${ first_vals.num_to_make } tests.`
     );
   }
@@ -713,7 +723,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
     //     also possibly repeat this message. Can we do something about that in
     //     a way that is also maintainable?
     warnings.push( 
-      log.warn({ code: `ALK0237`, context: `generating files`, },
+      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 }`
       )
     );
@@ -724,7 +734,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
   /** Missing number */
   if ( number_matcher === null ) {
     warnings.push( 
-      log.warn({ code: `ALK0238`, context: `generating files`, },
+      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 }`
       )
     );
@@ -737,7 +747,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
     //    than the first
     user_num = parseInt( number_matcher[ number_matcher.length - 1 ]);
     warnings.push(
-      log.warn({ code: `ALK0239`, context: `generating files`, },
+      log.warn({ code: `ALK0240`, context: `generating files`, },
         `This constrained random answers Step is ambiguous because it has more than 1 number. ALKiln will now use the last number in the Step (${ user_num }). The Step:\n      ${ text }`,
       )
     );
@@ -755,7 +765,7 @@ function get_number_of_Scenarios_to_generate2({ step, prev_num_to_make }) {
 
   if ( num_to_make !== user_num ) {
     warnings.push(
-      log.warn({ code: `ALK0240`, context: `generating files`, },
+      log.warn({ code: `ALK0241`, context: `generating files`, },
         `The author asked to make ${ user_num } tests, but maximum allowed is ${ num_to_make }. ALKiln will now make ${ num_to_make } tests. If you want to increase the maximum, use the MAX_TESTS_PER_GENERATOR_SCENARIO environment variable. Read more about environment variables at https://assemblyline.suffolklitlab.org/docs/alkiln/writing/#env-vars.`
       )
     );
@@ -794,7 +804,7 @@ function get_definitely_unqiue_Scenario_lines({
 
   let unqiue_Scenario_lines = [];
 
-  log.debug({ code: `ALK0244`, context: `generating files`, },
+  log.debug({ code: `ALK0245`, context: `generating files`, },
     `Trying to get get_definitely_unqiue_Scenario_lines`
   );
 
@@ -823,7 +833,7 @@ function get_definitely_unqiue_Scenario_lines({
 
   unqiue_Scenario_lines.push( ...tags_tweens, keyword_text );
 
-  log.debug({ code: `ALK0247`, context: `generating files`, },
+  log.debug({ code: `ALK0248`, context: `generating files`, },
     `Unique lines:`, unqiue_Scenario_lines
   );
 
@@ -949,7 +959,7 @@ function get_possibly_unique_lines_data({
   }  // Ends loop for every step
 
   if ( !found_at_least_1_significant_step ) {
-    let error = log.error({ code: `ALK0254`, context: `generating files`, },
+    let error = log.error({ code: `ALK0256`, context: `generating files`, },
       `ALKiln found 0 valid constraints Steps for the Scenario at line ${ scenario.location.line }: "${ scenario_description_for_logs({ scenario }) }". Check the Step docs at https://assemblyline.suffolklitlab.org/docs/alkiln/writing#constrained-random-answers for the correct language and syntax.`
     );
     misfits.add({ errors: [new Error( error )] });
@@ -1011,14 +1021,14 @@ function get_random_Story_Table({
   if ( misfits.errors.length > 0 ) { return { table: null, ...misfits }; }
 
   if ( !step.dataTable ) {
-    let error = log.error({ code: `ALK0250`, context: `generating files`, },
+    let error = log.error({ code: `ALK0251`, context: `generating files`, },
       `The table is missing for the constrained random answers Step at line ${ step.location.line }. The Step:`,
       get_flatter_table_Step({ step })
     );
     misfits.add({ errors: [ new Error( error ) ] });
 
   } else if ( step.dataTable.rows.length === 1 ) {
-    let error = log.error({ code: `ALK0251`, context: `generating files`, },
+    let error = log.error({ code: `ALK0252`, context: `generating files`, },
       `The body of the table is missing for the table of the constrained random answers Step at line ${ step.location.line }. There is only a header row. The Step:`,
       get_flatter_table_Step({ step })  );
     misfits.add({ errors: [new Error( error )] });
@@ -1058,7 +1068,7 @@ function get_random_Story_Table({
   }
 
   let table = story_table_parts.join(`\n`);
-  log.debug({ code: `ALK0253`, context: `generating files`, }, `Table:`, table );
+  log.debug({ code: `ALK0255`, context: `generating files`, }, `Table:`, table );
   return { table, ...misfits };
 }
 
@@ -1090,7 +1100,7 @@ function get_final_ids({ step_text }) {
 
   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 error = log.error({ code: `ALK0249`, context: `generating files`, }, missing_ids_msg );
+    let error = log.error({ code: `ALK0250`, context: `generating files`, }, missing_ids_msg );
     errors.push(new Error( error ));
   }
 
@@ -1193,7 +1203,7 @@ function pick_random_answer({ answers_str=`` }) {
     //    with problems that may not exist. We can always make the warnings
     //    louder later. Should we make them loud instead? And suggest the author
     //    should put the empty one in the middle?
-    log.debug({ code: `ALK0252`, context: `generating files` },
+    log.debug({ code: `ALK0254`, context: `generating files` },
       `**Quiet warning** - One of the constrained random answer choices in a row in this table is "". It could be on purpose or it could be a misplaced separator (";;"). The choices: "${ answers_str }"`
     );
   }
@@ -1425,9 +1435,9 @@ function get_warnings_docstring({ warnings_lines, indent }) {
    * */
   let doc_str_lines = [
     `"""`,
-    `━━━━━ Generator file warning or warnings ━━━━━`,
+    `――――― Generator file warnings ―――――`,
     ...warnings_lines,
-    `━━━━━`,
+    `―――――`,
     `"""`,
   ];
 
@@ -1490,7 +1500,7 @@ function save_files({ tests_path, artifacts_path, file_strings }) {
   fs.mkdirSync( tests_path, { recursive: true });
   fs.mkdirSync( artifacts_path, { recursive: true });
 
-  log.debug({ code: `ALK0267`, context: `generating files`, },
+  log.debug({ code: `ALK0269`, context: `generating files`, },
     `Saving ${ file_strings.length } newly generated files in "${ tests_path }"`
   );
 
@@ -1503,7 +1513,7 @@ function save_files({ tests_path, artifacts_path, file_strings }) {
     fs.appendFileSync( `${ artifacts_path }/${ filename }`, file_str );
   }
 
-  log.debug({ code: `ALK0268`, context: `generating files`, },
+  log.debug({ code: `ALK0270`, context: `generating files`, },
     `Saved new generated files:`, fs.readdirSync( tests_path )
   );
 }
@@ -1526,7 +1536,7 @@ function delete_previous_tests_from_sources_folders_for_ALKiln_developers({ test
    * @returns {undefined}
    * */
   if ( !fs.existsSync( tests_path )) { return; }
-  log.debug({ code: `ALK0266`, context: `generating files`, },
+  log.debug({ code: `ALK0268`, context: `generating files`, },
     `Deleting previously generated files:`, fs.readdirSync( tests_path )
   );
   fs.rmSync( tests_path, { recursive: true, force: true });
@@ -1708,13 +1718,13 @@ function get_tweens({
       tweens.push( generator_lines[ line_i ]);
     }
 
-    log.debug({ code: `ALK0245`, context: `generating files`, },
+    log.debug({ code: `ALK0246`, context: `generating files`, },
       `Got tween lines. Starting line (excluded):`, generator_lines[ end_index_of_prev ],
       `\nTweens:`, tweens,
       `\nEnding line (excluded):`, generator_lines[ start_index_of_next ]
     );
   } catch ( tween_error ) {
-    errors.push( new Error( log.error({ code: `ALK0246`, context: `generating files`, },
+    errors.push( new Error( log.error({ code: `ALK0247`, context: `generating files`, },
       `ALKiln got an error it is unfamiliar with when generating lines in between other lines starting on Gherkin AST line ${ start }. We would love to see your debug.txt`
     )));
     errors.push( tween_error );
@@ -1735,7 +1745,7 @@ function get_authors_indent({ located }) {
    *     given Gherkin location object.
    * */
   if ( typeof located !== `object` || !located.location ) {
-    debug.log({ code: `ALK0277`, context: `generating files`, }
+    log.debug({ code: `ALK0253`, context: `generating files`, }
       `Skipped get_authors_indent. Given argument:\n`,
       located
     );

package/lib/setup/generate.js

@@ -34,7 +34,7 @@ function generate_constrained_random_test_files() {
   }
 
   if ( all_errors.length > 0 ) {
-    log.throw({ code: `ALK0270`, context: `generating files`,
+    log.throw({ code: `ALK0272`, context: `generating files`,
       error: new Error( `ALKiln got error(s) when it tried to generate constrained random answers tests. See warnings and errors above.` )
     });
   };

package/lib/setup/validate.js

@@ -77,7 +77,7 @@ function parse_all_feature_files_in({ sources_path }) {
 
     if ( these_AST_errors.length > 0 ) {
       all_AST_errors.push( ...these_AST_errors );
-      log.warn({ code: `ALK0274`, context: `validating files`, },
+      log.warn({ code: `ALK0276`, context: `validating files`, },
         `There is a Gherkin syntax error(s) in "${ feature_path }"`,
         ...get_error_stacks({ errors: these_AST_errors })
       );

package/lib/steps.js

@@ -106,10 +106,21 @@ BeforeAll(async function() {
 
   // A little indirect, but the artifacts path should always have already been
   // created by now, either by `run_cucumber.js` or the relevant test
-  scope.paths.artifacts = session_vars.get_artifacts_path_name();
-  log = new Log({ path: scope.paths.artifacts, context: `steps` });
+
+  // // TODO: Is this causing the GitHub tests artifacts trouble? Because
+  // // `.get_artifacts_path_name()` is messing up somehow? That shouldn't be a
+  // // problem. That's the same method `Log` uses. Why does runtime_config not
+  // // have a value here?
+  // scope.paths.artifacts = session_vars.get_artifacts_path_name();
+  // log = new Log({ path: scope.paths.artifacts, context: `steps` });
+
+  console.log(`\n\n`, `scope.paths.artifacts:`, scope.paths.artifacts, `\n\n`);
+  // New attempt avoids passing in a path. For the record, this shouldn't help.
+  log = new Log({ context: `steps` });
   scope.set_log({ log_obj: log });
 
+  scope.paths.artifacts = session_vars.get_artifacts_path_name();
+
   scope.paths.debug_log = `${ scope.paths.artifacts }/${ log.debug_log_filename }`;
   scope.paths.report_log = `${ scope.paths.artifacts }/${ log.report_log_filename }`;
   scope.paths.report = `${ scope.paths.artifacts }/${ log.report_filename }`;
@@ -181,11 +192,11 @@ Before(async (scenario) => {
 // Add a check for an error page before each step? After each step?
 
 BeforeStep(async function ( step ) {
-  // TODO: Add a way for the reports to add "✔" or "✖" to the start of a Step
-  //    after it's been completed, as cucumber already does. Add a 'step' type
-  //    and additional success/failure information, though that may be
-  //    challenging
-  reports.addToReport(scope, { type: `row`, value: step.pickleStep.text });
+  // Discuss: In the report, add a way for the reports to add "✔" or "✖" to the
+  //    start of a Step after it's been completed, as cucumber already does. Add
+  //    a 'step' type and additional success/failure information, though that
+  //    may be challenging.
+  reports.addToReport(scope, { type: `row info`, value: step.pickleStep.text });
   reports.indent();
 });
 
@@ -352,18 +363,8 @@ Given(/the max(?:imum)? sec(?:ond)?s for each step (?:in this scenario )?is (\d+
 // Story
 //#####################################
 //#####################################
-// TODO: Consider more permissive sentences:
-// with(?: this data| these answers)?:?
-// with(?:.*):?
-// ^(?:the user|I)? gets? to ?.*?(".*") ?with .*?
-// .*gets? to ?.*?(".*") ?with.*?
-// More readable?:
-// I? ?gets? to ?.*?(".*") ?with.*?(?:this data:)?
-// get to + stop at (?:gets? to|stops? at)
-// `before "a", "b", "c" and after` -> `"a", "b", "c"`
-// Impossible with cucumber `before "a", "b", "c" and after` -> `["a", "b", "c"]`
 const INCLUDING_QUOTES_REGEX = /"([^"]*)"/g;
-When(/I? ?gets? to ?.*?(".*").*?with.*?(?:this data:)?/, {timeout: -1}, async (target_ids, raw_var_data) => {
+When(/I? ?gets? to ?.*?(".*").*?with.*?(?:this data:)?/i, {timeout: -1}, async (target_ids, raw_var_data) => {
   /* NO CUCUMBER TIMEOUT. Must handle timeout ourselves:
   * https://github.com/cucumber/cucumber-js/blob/master/docs/support_files/timeouts.md#disable-timeouts
   * Iterate in here to keep timeout reasonable */
@@ -439,7 +440,7 @@ When(/I? ?gets? to ?.*?(".*").*?with.*?(?:this data:)?/, {timeout: -1}, async (t
           if ( error.was_found ) { await scope.throwPageError( scope, { id: id }); }
           resolve();
         } catch ( err ) {
-          let err_msg = `An error occurred when ALKiln tried to answer fields on question with the id "${ id }". See above for warnings and errors.`
+          let err_msg = `ALKiln ran into an error it tried to answer fields on the page with the question id "${ id }". The text above might have more information.`
           reports.addToReport( scope, { type: `error`, code: `ALK0062`, value: err_msg });
           // Throw error instead?
           reject( err );
@@ -498,54 +499,6 @@ When(/I? ?gets? to ?.*?(".*").*?with.*?(?:this data:)?/, {timeout: -1}, async (t
   reports.addToReport(scope, { type: `plain`, value: `` });
 });
 
-/**
- *
- * | var | possible_values |
- * | favorite_color | blue;; green;; red |
- *
- * @param raw_var_data { [{ var, possible_values }] } List of table row objects
- * @param raw_var_data[i].var {str} Name of the variable to set
- * @param raw_var_data[i].possible_values {str} Format is ";;" separated
- *    possible values for the variable (lawyers use ";" grammatically)
- * */
-
-/** Need a sentence for:
- * And I will go to the interview at the address ("")
- * And I will run (100) constrained random tests
- * And those tests should get to one of these page ids - [("lsdjf", "sldkjf")]
- * And I will get there with random choices from this data:
- *   | var | possible_values |
- *   | favorite_color | blue;; green;; red |
- *
- * Write files
- * 1. Make an object from the given constraints table (split by single _and_
- *    double quotes? Just double quotes? Document author _must_ use double
- *    quotes?)
- * 1. Make sure that it's not the same as previous objects
- * 1. Far in the future: Make sure it's not the same as a test the author
- *    already wrote (need to wrap cucumber for this to run all random tests
- *    last)
- * 1. Make a Scenario description using the iteration number
- * 1. Add to one big file (name includes datetime) for all these Scenarios
- * 1. Increment iteration number
- * 1. Leave them there to get run later
- *
- * Supposedly more performant to write one big file [^citation needed]. Not
- *    sure it matters that much yet. If we do want to optimize, maybe using
- *    a write stream directly is the way to go.
- *
- * Command:
- * I run (\d*) random tests for/at "interview.yml" that will reach one of these question/page ids (\[".*"]) with these constraints: (table)
- * (\d*) random at "interview.yml" will reach one/any of (\[.*]) with: (table)
- *
- * Given I generate 100 random tests
- * And I test the interview at ""
- * And I reach any of these question/page ids: ""
- * And I answer with/give these possible answers: (table)
- * I generate 100 random tests for the interview at "" to reach any of the question ids [] with these possible answers
- *
- */
-
 
 //#####################################
 //#####################################

package/lib/utils/Log.js

@@ -10,7 +10,7 @@ const files = require(`./files`);
 /**
  * Future issues:
  * - [ ] Save logs from GitHub actions as well? Users can download them
- *   themselves, but this might not be clear to them
+ *   themselves, but this might not be clear to them.
  * - [ ] Capture cucumber ProgressFormatter logs instead of making them
  *   ourselves?
  * - [ ] keeping report separate for now (can just be an issue to integrate)
@@ -18,9 +18,8 @@ const files = require(`./files`);
  *   message to prepend the accompanying log code, etc (all except the `before`
  *   prop). Before this, do UX research to see if the current format is as
  *   confusing to authors as it seems from this end.
- * - [ ] Discuss: Put artifacts path name getting, setting, deleting, in here so
- *   we can avoid importing session_vars and then use Log in session_vars.js
- * - [ ] Discuss: Should `.error()` return an Error?
+ * - [ ] Discuss: Should `.error()` return an Error? See discussion:
+ *   https://github.com/SuffolkLITLab/ALKiln/discussions/988
  * */
 
 /**
@@ -148,8 +147,10 @@ class Log {
      * const log = new Log({ path: "_alkiln-123", context: "setup" });
      * */
 
+    console.trace(`\n\nCreating from Log`);
+
     // These records help internal tests check for correct behavior
-    this.internal_tests_records = [];
+    this.internal_log_records = [];
 
     let dir = path;  // eventually, convert to this.dir instead of this.path
 
@@ -163,10 +164,11 @@ class Log {
     if ( context ) { context = context + ` log`; }
     else { context = `log`; }
     let files_msg = `ALKiln will save test results files at "${ this.path }"`;
+    console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. Calculated path:`, this.path);
     if ( is_new_folder ) {
       this.info({ code: `ALK0214`, context, }, files_msg );
     }  else {
-      this.debug({ code: `ALK0275`, context, }, files_msg );
+      this.debug({ code: `ALK0277`, context, }, files_msg );
     }
 
     // Has this `Log` ever failed to append to the debug file?
@@ -174,6 +176,10 @@ class Log {
 
   }
 
+  clear_internal_log_records() {
+    this.internal_log_records = [];
+  }
+
   _is_new_folder({ dir }) {
     /** Check if the artifacts folder is a new folder.
      * 
@@ -214,23 +220,30 @@ class Log {
      * */
     try {
 
+      console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. Given dir:`, dir);
+
       // GitHub actions pass in a dir, but other processes, like
       //    ALKilnInThePlayground, don't have a path
       if ( !dir ) {
+        console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. No dir given`);
         if ( session_vars.get_artifacts_path_name() ) {
+          console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. Artifacts path already has a name`);
           dir = session_vars.get_artifacts_path_name();
         } else {
+          console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. Making brand new artifacts path`);
           dir = files.make_artifacts_folder();
         }
       }
 
       if ( !fs.existsSync( dir )) {
+        console.log(`🐛🐛🐛🐛🐛 ALKTemp debugging Log path. Artifacts path dir doesn't yet exist`);
         files.make_artifacts_folder( dir );
       }
 
       return { dir, errors: [] };
 
     } catch ( error_making_dir ) {
+      // Logs should fail silently. With no dir, though, we can't save the error
       return { dir, errors: [ error_making_dir ]};
     }
     
@@ -373,8 +386,8 @@ class Log {
 
     // Throw whatever we can throw
     if ( do_throw ) {
-      // WARNING: If someone catches the error we throw, these logs will still
-      // show. The final resulting logs may become confusing.
+      // WARNING: If someone catches the error we throw, these strings will get
+      // logged. The final resulting logs may become confusing.
       try {
         console.error( `\n\n\n${before}${metadata_str}:`, ...logs );
       } catch ( pre_throw_error ) {
@@ -469,7 +482,7 @@ class Log {
     } = debug_opts;
     logs = logs || [];
 
-    this.internal_tests_records.push({ opts: debug_opts, logs });
+    this.internal_log_records.push({ opts: debug_opts, logs });
 
     // "warning" level and icon for for internal devs we use to avoid disrupting
     // the info authors are looking for

package/lib/utils/_alkiln-constrained_random_tests_old.js

@@ -1,3 +1,52 @@
+
+/**
+ *
+ * | var | possible_values |
+ * | favorite_color | blue;; green;; red |
+ *
+ * @param raw_var_data { [{ var, possible_values }] } List of table row objects
+ * @param raw_var_data[i].var {str} Name of the variable to set
+ * @param raw_var_data[i].possible_values {str} Format is ";;" separated
+ *    possible values for the variable (lawyers use ";" grammatically)
+ * */
+
+/** Need a sentence for:
+ * And I will go to the interview at the address ("")
+ * And I will run (100) constrained random tests
+ * And those tests should get to one of these page ids - [("lsdjf", "sldkjf")]
+ * And I will get there with random choices from this data:
+ *   | var | possible_values |
+ *   | favorite_color | blue;; green;; red |
+ *
+ * Write files
+ * 1. Make an object from the given constraints table (split by single _and_
+ *    double quotes? Just double quotes? Document author _must_ use double
+ *    quotes?)
+ * 1. Make sure that it's not the same as previous objects
+ * 1. Far in the future: Make sure it's not the same as a test the author
+ *    already wrote (need to wrap cucumber for this to run all random tests
+ *    last)
+ * 1. Make a Scenario description using the iteration number
+ * 1. Add to one big file (name includes datetime) for all these Scenarios
+ * 1. Increment iteration number
+ * 1. Leave them there to get run later
+ *
+ * Supposedly more performant to write one big file [^citation needed]. Not
+ *    sure it matters that much yet. If we do want to optimize, maybe using
+ *    a write stream directly is the way to go.
+ *
+ * Command:
+ * I run (\d*) random tests for/at "interview.yml" that will reach one of these question/page ids (\[".*"]) with these constraints: (table)
+ * (\d*) random at "interview.yml" will reach one/any of (\[.*]) with: (table)
+ *
+ * Given I generate 100 random tests
+ * And I test the interview at ""
+ * And I reach any of these question/page ids: ""
+ * And I answer with/give these possible answers: (table)
+ * I generate 100 random tests for the interview at "" to reach any of the question ids [] with these possible answers
+ *
+ */
+
 /**
  * If not doing a 1-Scenario requirement
  *