@suffolklitlab/alkiln 5.13.2 → 5.13.3-feat-random

package/lib/setup/artifacts.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const session_vars = require(`../utils/session_vars`);
+const files = require(`../utils/files`);
+const Log = require(`../setup/artifacts.js`);
+
+/** Reset and refresh artifacts path name */
+
+session_vars.delete_artifacts_path_name();
+
+// process.argv is a list of strings of commands and args.
+// 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( argv.path );
+
+session_vars.save_artifacts_path_name( artifacts_path );
+
+// Leave the config Project name value as it is. Local developers find it
+//    useful to re-use that value.

package/lib/setup/generate.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const Log = require(`../utils/Log`);
+const set_sources_paths = require(`../utils/set_sources_paths`);
+const TestGenerator = require(`./TestGenerator.js`);
+
+// process.argv is a list of strings of commands and args.
+// If using `npm run cucumber` (as opposed to the bin commands),
+// use `--` before `--sources=./foo`
+const argv = require(`minimist`)( process.argv.slice(2) );
+const log = new Log({ path: argv.path, context: `generating files` });
+// Run script
+generate_constrained_random_test_files();
+
+
+function generate_constrained_random_test_files() {
+  /** Executable that generates constrained random answers tests and throws
+   *    errors.
+   * 
+   * Takes no arguments - uses command line arguments instead.
+   * */
+  let all_errors = [];
+
+  // Every file that's executed separately needs to figure out the location of
+  //    the sources folders.
+  let sources_paths = set_sources_paths({ log });
+  let generator = new TestGenerator();
+  for ( let sources_path of sources_paths ) {
+    let { errors: generating_errors } = generator.create({
+      sources_path,
+      logger: log
+    });
+    all_errors.push( ...generating_errors );
+  }
+
+  if ( all_errors.length > 0 ) {
+    log.throw({ code: `ALK0270`, 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/get_Gherkin_AST.js

@@ -0,0 +1,26 @@
+const Gherkin = require(`@cucumber/gherkin`);
+const Messages = require(`@cucumber/messages`);
+
+module.exports = function get_Gherkin_AST({ file_text }) {
+  /** Return Gherkin parser's abstract syntax tree of the given generator file
+   *
+   * @param {object} obj - Named arguments
+   * @param {string} file_text - The generator file's text contents
+   *
+   * @returns {object} - Gherkin parser's AST of the given generator file
+   * */
+  let AST = null;
+  let parse_errors = [];
+  try {
+    let uuidFn = Messages.IdGenerator.uuid();
+    let builder = new Gherkin.AstBuilder(uuidFn);
+    let matcher = new Gherkin.GherkinClassicTokenMatcher(); // or Gherkin.GherkinInMarkdownTokenMatcher()
+
+    let parser = new Gherkin.Parser(builder, matcher);
+    AST = parser.parse( file_text );
+  } catch ( gherkin_error ) {
+    parse_errors.push( gherkin_error );
+  }
+
+  return { AST, errors: parse_errors };
+}

package/lib/setup/validate.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const fs = require(`fs`);
+const fast_glob = require(`fast-glob`);
+
+const globals = require(`../globals`);
+const Log = require(`../utils/Log`);
+const set_sources_paths = require(`../utils/set_sources_paths`);
+const get_Gherkin_AST = require(`./get_Gherkin_AST`);
+const get_error_stacks = require(`../utils/get_error_stacks`);
+
+
+/**
+ * TODO: Document that generator files need to have valid Gherkin syntax
+ * TODO: Document how to read Gherkin syntax errors. E.g.
+ *     (3:1): expected: #EOF, #Language, #TagLine, #FeatureLine, #Comment, #Empty, got 'Scenario: bar'
+ *     (6:1): expected: #EOF, #TableRow, #DocStringSeparator, #StepLine, #TagLine, #ExamplesLine, #ScenarioLine, #RuleLine, #Comment, #Empty, got 'Feature: zoo'
+ * */
+
+
+// process.argv is a list of strings of commands and args.
+// If using `npm run cucumber` (as opposed to the bin commands),
+// use `--` before `--sources=./foo`
+const argv = require(`minimist`)( process.argv.slice(2) );
+const log = new Log({ path: argv.path, context: `validating files` });
+// Run script
+validate_Gherkin_files();
+
+
+function validate_Gherkin_files() {
+  /** Accumulates syntax errors for all `.feature`` test files, including
+   *    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 = [];
+  for ( let sources_path of sources_paths ) {
+    let { errors: files_errors } = parse_all_feature_files_in({ sources_path });
+    all_errors.push( ...files_errors );
+  }
+
+  // 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 ) {
+    log.throw({ code: `ALK0230`, context: `validating files`,
+      error: new Error( `ALKiln ran into Gherkin syntax error(s) when parsing your test feature files. See warnings and errors above.` )
+    });
+  };
+}
+
+
+function parse_all_feature_files_in({ sources_path }) {
+  /** Returns accumulated list of Gherkin errors from all files in the
+   *    docassemble "sources" folder (or an empty list).
+   * 
+   * @param {object} obj - Named arguments
+   * @param {object} obj.sources_path - Path to the docassemble "sources" folder
+   * 
+   * @returns {{errors: [Error]}} Obj with an `error` prop that is a list of
+   *    Error instances. Follows the format of other functions that return
+   *    accumulated errors.
+   * */
+  let all_AST_errors = [];
+
+  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 { AST, errors: these_AST_errors } = get_Gherkin_AST({ file_text });
+
+    if ( these_AST_errors.length > 0 ) {
+      all_AST_errors.push( ...these_AST_errors );
+      log.warn({ code: `ALK0274`, context: `validating files`, },
+        `There is a Gherkin syntax error(s) in "${ feature_path }"`,
+        ...get_error_stacks({ errors: these_AST_errors })
+      );
+    }
+
+  }  // ends for each file path
+
+  return { errors: all_AST_errors };
+}

package/lib/steps.js

@@ -5,6 +5,8 @@ const {
   Given,
   After,
   Before,
+  BeforeStep,
+  AfterStep,
   BeforeAll,
   AfterAll,
   setDefaultTimeout //,
@@ -18,7 +20,7 @@ const { v4: uuidv4 } = require('uuid');
 
 // Ours
 const scope = require('./scope');
-const log = require('./utils/log');
+const Log = require(`./utils/Log`);
 const session_vars = require('./utils/session_vars');
 const files = require('./utils/files' );
 const reports = require(`./utils/reports`);
@@ -82,7 +84,9 @@ let click_with = {
   pc: 'click',
 };
 
-BeforeAll(async () => {
+let log = null;
+
+BeforeAll(async function() {
   scope.showif_timeout = 600;
   // TODO: Do these really need to be maps? As sets, they may make the output
   // more predictable to the user, but they add complexity.
@@ -95,29 +99,30 @@ BeforeAll(async () => {
   // Store path names for files and docs created for the tests
   scope.paths = {};
 
-  // TODO: figure out how to test file and folder creation stuff,
-  // especially when setup is excluded from the flow.
+  // // Make the 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.
+  // // The value we are saving is used by at least run_cucumber.js.
 
-  // Make the 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.
-  // The value we are saving is used by at least run_cucumber.js.
-  session_vars.save_artifacts_path_name( scope.paths.artifacts );
+  // 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` });
+  scope.set_log({ log_obj: log });
 
-  scope.paths.report = `${ scope.paths.artifacts }/report.txt`;
-  scope.paths.failures = `${ scope.paths.artifacts }/${ log.unexpected_filename }`;
-  scope.paths.debug_log = `${ scope.paths.artifacts }/${ log.debug_log_file }`;
-  fs.writeFileSync( scope.paths.debug_log, "" );
+  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 }`;
+  scope.paths.debug_of_unexpected = `${ scope.paths.artifacts }/${ log.temp_unexpected_debug_log_filename }`;
+  scope.paths.report_of_unexpected = `${ scope.paths.artifacts }/${ log.unexpected_filename }`;
 
   reports.create( scope );
 });
 
 Before(async (scenario) => {
 
-  // Useful for those with a lot of tests
-  // Is unable to print the first Scenario name for some reason
-  console.log('');
-  process.stdout.write(`Scenario: ${ scenario.pickle.name }: `);
+  // Start the running "progress bar" for the Scenario
+  log.stdout({}, `\nScenario: ${ scenario.pickle.name }: `);
 
   // Create browser, which can't be created in BeforeAll() where .driver doesn't exist for some reason
   if (!scope.browser) {
@@ -175,6 +180,14 @@ 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 });
+  reports.indent();
+});
 
 //#####################################
 //#####################################
@@ -342,14 +355,24 @@ Given(/the max(?:imum)? sec(?:ond)?s for each step (?:in this scenario )?is (\d+
 // TODO: Consider more permissive sentences:
 // with(?: this data| these answers)?:?
 // with(?:.*):?
-When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)" with this data:?/, {timeout: -1}, async (target_id, raw_var_data) => {
+// ^(?: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) => {
   /* 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 */
 
   // Note: Why do we not just stop when we've used all the vars in the table or
   // reach the last var? Vars are not required to be given in sequence and pages that
-  // have non-button fields don't usually have a var assigned to the 'continue' button.
+  // have non-button fields often don't have a var assigned to the 'continue' button.
+  // It is optional for the table to use all the vars and some vars may be used
+  // multiple times.
   // Alternative: require vars even for 'continue' pages. Then in loop require at least one var
   // to be found on a page before hitting 'continue'. That requires detecting navigation because
   // pages with fields will not have a var for the continue button, so there will
@@ -357,10 +380,18 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
   // It also seems harsh, but more reliable.
   // Ask developers what they'd like.
 
+  let ids_as_list = Array.from(
+    target_ids.matchAll( INCLUDING_QUOTES_REGEX ),
+    ( match ) => { return match[ 1 ]; }
+  );
+  let sanitized_ids = ids_as_list.map(( risky_id ) => {
+    return scope.to_docassemble_sanitized_id( risky_id );
+  });
 
   let supported_table = await scope.normalizeTable( scope, { raw_var_data });
 
-  let { question_has_id, id, id_matches } = await scope.examinePageID( scope, target_id );
+  let id = await scope.get_page_id( scope );
+  let id_matches = id && sanitized_ids.includes( id );
   // Until we reach the target page, hit an error, or time out (take too long)
   while ( !id_matches ) {
     let custom_timeout = new Promise(function( resolve, reject ) {
@@ -368,8 +399,8 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
       // Set up the timeout that avoids infinite loops
       let on_page_timeout = async function() {
 
-        let non_reload_report_msg = `The target id was "${ target_id }", but it took `
-        + `too long to try to reach it (over ${ scope.timeout/1000/60 } min). The `
+        let non_reload_report_msg = `The target id or ids were ${ target_ids }, but it took `
+        + `too long to try to reach a valid id (over ${ scope.timeout/1000/60 } min). The `
         + `test got stuck on "${ id }".`
         let error = non_reload_report_msg;
         await scope.handle_page_timeout_error( scope, { non_reload_report_data: {
@@ -386,7 +417,7 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
       // Maybe list of timeout and/or interval ids in state that can all be cleared at once?
       (async function() {
         try {
-          let { question_has_id, id, id_matches } = await scope.examinePageID( scope );
+          let id = await scope.get_page_id( scope );
 
           // THIS FUNCTION ACTUALLY MATTERS
           // Add special rows. Basically, do weirder things.
@@ -396,20 +427,19 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
             from_story_table: true,
           });
 
-          log.debug({
-            type: `info`,
-            code: `ALK0061`,
-            pre: `Rows, including special rows:, ${JSON.stringify( ensured_var_data )}`,
-          });
+          log.debug({ code: `ALK0061`, context: `table`, },
+            `Rows, including special rows:`, ensured_var_data
+          );
 
           // THIS FUNCTION ACTUALLY MATTERS
           // Some errors happen in there to be closer to the relevant code. We'd have to try/catch anyway.
           let error = await scope.setFields(scope, { var_data: ensured_var_data, id, ensure_navigation: true });
 
+          // TODO: use Log class to throw this error?
           if ( error.was_found ) { await scope.throwPageError( scope, { id: id }); }
           resolve();
         } catch ( err ) {
-          let err_msg = `Error occurred when tried to answer fields on question "${ id }".`
+          let err_msg = `An error occurred when ALKiln tried to answer fields on question with the id "${ id }". See above for warnings and errors.`
           reports.addToReport( scope, { type: `error`, code: `ALK0062`, value: err_msg });
           // Throw error instead?
           reject( err );
@@ -422,7 +452,8 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
     await custom_timeout;
 
     // Prep for next loop
-    ({ question_has_id, id, id_matches } = await scope.examinePageID( scope, target_id ));
+    id = await scope.get_page_id( scope );
+    id_matches = id && sanitized_ids.includes( id );
 
   }  // ends while !id_matches
   // Can anything unsatisfactory get through here?
@@ -441,7 +472,7 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
   // Add full used table to report so it can be copied if needed.
   // TODO: Should we/How do we get this in the final scenario report instead of here?
   reports.addToReport( scope, { type: `note info`, code: `ALK0063`, value: `\n${ ' '.repeat(2) }Rows that got set:` });
-  reports.addToReport( scope, { type: `step info`, code: `ALK0064`, value: `${ ' '.repeat(4) }And I get to the question id "${ target_id }" with this data:` });
+  reports.addToReport( scope, { type: `step info`, code: `ALK0064`, value: `${ ' '.repeat(4) }And I get to any of the question ids ${ target_ids } with this data:` });
   reports.addToReport(scope, { type: `row info`, code: `ALK0065`, value: `${ ' '.repeat(6) }| var | value | trigger |`, });
   let at_least_one_row_was_NOT_used = false;
   for ( let row of sorted_rows ) {
@@ -467,6 +498,54 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
   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
+ *
+ */
+
 
 //#####################################
 //#####################################
@@ -972,7 +1051,7 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
           }  // ends if !has_content
 
           if ( buttons_exist ) {
-            process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
+            log.stdout({}, `\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
           }
 
           resolve();
@@ -1150,6 +1229,22 @@ When(/I set the address of ?(?:the var(?:iable)?)? "([^"]+)" to "([^"]+)"/, { ti
 // Next macro - download sequence?
 
 
+//#####################################
+//#####################################
+// Messages from ALKiln to author
+//#####################################
+//#####################################
+
+const LOG_CODE_REGEX = /ALKiln\d\d\d\d/;
+Given(/ALKiln warns the author/i, async ( warnings_text ) => {
+  /** Create a warning message for the author files they wrote to generate
+   *    constrained random answers tests.
+   * 
+   * @param {str} warnings_text - Warning text generated by ALKiln
+   * */
+  reports.addToReport( scope, { type: `as_is`, value: warnings_text });
+})
+
 
 //#####################################
 //#####################################
@@ -1187,6 +1282,8 @@ Given(/the Scenario report should not include/i, async ( report_text ) => {
 Given(/the final Scenario status should be "([^"]+)"/i, async ( expected_status ) => {
   /** WARNING: If a Step will fail, this Step must come first.
   * 
+  * TODO: Status "A" ambiguous (internal)
+  *
   * Prepare to test that the Scenario completes with the correct status. */
   scope.expected_status = expected_status.toUpperCase();
 });
@@ -1263,11 +1360,24 @@ Then(/I fail to delete (\d) detected interview(?:s)? and get no error __internal
 //#####################################
 //#####################################
 
+AfterStep(async function({ result }) {
+  // TODO: Abstract this
+  if ( result.status === `PASSED` ) { log.stdout({ records_only: true }, `.`); }
+  else if ( result.status === `FAILED` ) { log.stdout({ records_only: true }, `F`); }
+  else if ( result.status === `UNDEFINED` ) { log.stdout({ records_only: true }, `U`); }
+  else if ( result.status === `SKIPPED` ) { log.stdout({ records_only: true }, `-`); }
+  else if ( result.status === `PENDING` ) { log.stdout({ records_only: true }, `P`); }
+
+  reports.outdent();
+});
+
 After(async function(scenario) {
 
   // Log errors
   if ( scenario.result.message ) {
-    log.debug({ type: `info`, code: `ALK0091`, pre: `cucumber error: ${ scenario.result.message }` }); //, verbose: true });
+    log.debug({ code: `ALK0091`, context: `scenario`, },
+      scenario.result.message
+    );
   }
 
   let changeable_test_status = scenario.result.status;
@@ -1297,11 +1407,9 @@ After(async function(scenario) {
   reports.saveFinalScenarioData( scope, { status: changeable_test_status });
 
   if (changeable_test_status !== `PASSED`) {
-    log.debug({
-      type: `error`,
-      code: `ALK0094`,
-      pre: `Non-passed status occurred while running test: ${changeable_test_status}`,
-    });
+    log.debug({ code: `ALK0094`, level: `warn`, },
+      `Non-passed status occurred while running test: ${ changeable_test_status }`
+    );
 
     if ( scope.page ) {
 
@@ -1397,8 +1505,9 @@ After(async function(scenario) {
           + `Expected status: ${scope.expected_status}. `
           + `See the report for details.`;
       let code = `ALK0099`;
-      log.debug({ type: `error`, code: code, pre: msg, })
-      expected_status_err_msg = `🤕 ${ code } ERROR: ${ msg }`
+      expected_status_err_msg = log.debug({ code: code, level: `error`, },
+        msg
+      );
     }
   }
   scope.expected_status = null;  // reset for next Scenario
@@ -1418,17 +1527,25 @@ After(async function(scenario) {
     // Make sure that tests which ALKiln has calculated as failed
     // cause a cucumber error later. Just changing the status to `FAILED`
     // causes unhelpful cucumber errors. TODO: Add to internal docs.
-    log.debug({
-      type: `error`,
-      code: force_failure_code,
-      pre: force_failure_msg
-    });
+    // TODO: Should we move this to where the error is thrown?
+    log.debug({ code: force_failure_code, level: `error`, },
+      force_failure_msg
+    );
     // TODO: Look into setDefinitionFunctionWrapper to catch errors
     // of failing tests that should indeed be failing:
     // https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/api_reference.md#setdefinitionfunctionwrapperwrapper
     need_to_force_failed_status = true;
   }
 
+  // Not sure if this is necessary
+  if ( changeable_test_status === 'PASSED' ) {
+    log.stdout({ records_only: true }, `.` );
+  } else if ( changeable_test_status === `SKIPPED` ) {
+    log.stdout({ records_only: true }, `-` );
+  } else {
+    log.stdout({ records_only: true }, changeable_test_status[0].toUpperCase() );
+  }
+
   let signout_succeeded = true;
   let signout_error_msg = ``;
   // If there is a page open, then sign out and close it
@@ -1482,9 +1599,10 @@ After(async function(scenario) {
       // going to the wrong file). If it becomes a problem we can track it down later.
       if ( visible_keys.length > 0 ) {
         // Can an API key ever see an interview that it can't delete?
-        log.info({ type: `internal warning`, code: `ALK0197`,
-          pre: `The API key can see ${ visible_keys.length } interviews that were not deleted: ${ visible_keys.join( ', ' ) }`
-        });
+        log.debug({ code: `ALK0197`, context: `internal`, level: `warn`, }
+          `The API key can see ${ visible_keys.length } interviews that were not deleted:`,
+          visible_keys
+        );
       }
     } catch ( error ) {
       // Deleting interviews is nice, but not non-critical. Don't bother the
@@ -1494,7 +1612,9 @@ After(async function(scenario) {
       // interview. If it becomes a problem we can track it down later.
       // Consider add "internal" to docs: "If you see this, make an
       // issue in ALKiln with your debug/verbose log"
-      log.info({ type: `internal warning`, code: `ALK0198`, pre: `Error while cleaning up interviews.`, data: error });
+      log.debug({ code: `ALK0198`, context: `internal`, level: `warn`, error },
+        `Cleaning up interviews incomplete, but unimportant.`
+      );
     }
   }
 
@@ -1513,11 +1633,16 @@ After(async function(scenario) {
     throw new Error( `🤕 ${ force_failure_code } unreachable ERROR: ${ force_failure_msg }` );
 
   } else if ( internal_errors.length > 0 ) {
-    log.info({ type: `internal error`, code: `ALK0203`, pre: `No need to force failed status and yet there are error messages. ${ errors.join( errors, '\n') }` });
+    log.debug({ code: `ALK0203`, context: `internal`, level: `warn`, },
+      `There was no need to force failed status and yet there are error messages.`,
+      internal_errors
+    );
   }
 
   // Find the race condition.
-  log.debug({ type: `cucumber`, code: `ALK0100`, verbose: true, pre: `Scenario AfterStep() message`, data: scenario.result.message });
+  log.debug({ code: `ALK0100`, context: `scenario`, },
+    `Scenario After() message:`, scenario.result.message
+  );
 
 });