@suffolklitlab/alkiln 5.13.2 → 5.13.3-feat-random

package/lib/run_cucumber.js

@@ -1,21 +1,43 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
+const fast_glob = require(`fast-glob`);
+const path = require(`path`);
 const cucumber_api = require('@cucumber/cucumber/api');
 
-const log = require('./utils/log');  // These always log in the console
+const globals = require(`./globals`);
+const Log = require('./utils/Log');
 const session_vars = require('./utils/session_vars');
+const set_sources_paths = require(`./utils/set_sources_paths`);
+
+// TODO: Remove after merging Log class
+const files = require('./utils/files');
 
 const SUMMARY_FILENAME = `cucumber-report.txt`;
 
 
-function build_config( command_args ) {
+function build_config( cli_args ) {
+  /** Use the command line arguments to build the cucumberjs config object.
+   * 
+   * @param {string?} - Arguments passed to the command line.
+   * 
+   * @returns {object} - cucumberjs config object
+   * */
+  // ========== TODO: Abstract after merging Log class PR
   // Turn all the paths to the sources folders into paths to the feature files
   let sources_paths = session_vars.get_sources_paths();
   let feature_paths = [];
-  for ( let source of sources_paths ) {
-    feature_paths.push( `${ source }/*.feature` );
+
+  // Get all the paths for the right feature files (for cucumber to use)
+  for ( let sources_path of sources_paths ) {
+    // Ignore feature files that we parsed ourselves
+    let glob = fast_glob.sync(
+      `${ sources_path }/**/*.feature`,
+      { ignore: [`${ sources_path }/${ globals.generators_prefix }*.feature`] }
+    );
+    feature_paths.push( ...glob );
   }
+  // ========== Ends TODO: Abstract
 
   const config = {
     publishQuiet: true,
@@ -27,7 +49,7 @@ function build_config( command_args ) {
 
   // Normalize tag expressions, if there are any
   // Joining and splitting handles both tags surrounded with `""` or those without `""`
-  let tags = command_args[`_`].join(` `).split(` `);
+  let tags = cli_args[`_`].join(` `).split(` `);
   // If there was no tag expression, `tags` is ['']. Remove that item.
   tags = tags.filter(function(entry) { return entry !== ""; })
   if ( tags.length > 0 ) {
@@ -53,11 +75,18 @@ function build_config( command_args ) {
 };  // Ends build_config()
 
 
-(async function main() {
+async function main() {
   /** Create the cucumber config, run the tests, create and
-  *   manipluate the output. */
+  *   manipulate the output. */
+
   const environment = { cwd: process.cwd() };
-  log.info({ type: `run`, code: `ALK0049`, pre: `environment`, data: environment });
+  log.info({ code: `ALK0049`, context: `pre_run environment` },
+    environment
+  );
+
+  // ========== TODO: Abstract after merging Log class PR
+  let artifacts_path = files.make_artifacts_folder();
+  session_vars.save_artifacts_path_name( artifacts_path );
 
   // We'll use the user info to construct the possible paths to /sources
   let id = session_vars.get_user_id();
@@ -65,8 +94,9 @@ function build_config( command_args ) {
   let project = session_vars.get_user_project_name();
 
   // process.argv is a list of strings of commands and args.
-  // If using `npm run cucumber`, use `--` before `--sources=./foo`
-  let argv = require(`minimist`)( process.argv.slice(2), {
+  // If using `npm run cucumber` (as opposed to the bin commands),
+  // use `--` before `--sources=./foo`
+  const argv = require(`minimist`)( process.argv.slice(2), {
     default: {
       sources: [
         `./docassemble/*/data/sources`,  // In GitHub folder
@@ -75,58 +105,78 @@ function build_config( command_args ) {
       ],
     }
   });
-  
-  // Make sure `sources` is always a list
-  let sources_list = argv.sources;
-  if ( typeof argv.sources === `string` ) {
-    sources_list = [ argv.sources ];
-  }
 
-  let one_dir_exists = session_vars.set_sources_paths( sources_list );
-  if ( !one_dir_exists ) {
-    // If we don't throw, it'll be more confusing when no tests run
-    let msg = `ALKiln can't find your "sources" folder(s). See above for details.`;
-    let code = `ALK0050`
-    log.error({ type: `run`, code: code, pre: msg });
-    throw new ReferenceError(`🤕 ${ code } run ERROR: ${ msg }`);
-  }
+  // ========== Ends TODO: Abstract
   
   const { runConfiguration } = await cucumber_api.loadConfiguration({
     provided: build_config( argv ),
   }, environment);
+  log.info({ code: `ALK0051`, context: `pre_run config`, },
+    runConfiguration
+  );
 
-  log.info({ type: `run`, code: `ALK0051`, pre: `runConfiguration`, data: runConfiguration });
-
-  var path = require(`path`);
-  var codeDir = path.dirname(require.main.filename);
-  log.info({ type: `run`, code: `ALK0052`, pre: `working directory`, data: codeDir });
+  const codeDir = path.dirname(require.main.filename);
+  log.info({ code: `ALK0052`, context: `pre_run directory`, },
+    codeDir, `\n\n`
+  );
   const support = await cucumber_api.loadSupport({ support: {
     requireModules: [ `${ codeDir }/index.js` ],
     requirePaths: [ `${ codeDir }/index.js` ],
     importPaths: [],
   }, sources: {paths: []}}, environment);
 
-  log.info({ type: `run`, code: `ALK0053`, pre: `working directory`, data: codeDir });
-  log.info({ type: `plain`, pre: `\n\n` });
-
+  // ====================
+  /** Run */
+  // ====================
   const { success } = await cucumber_api.runCucumber({...runConfiguration, support});
+  // ====================
+
+  /** Write to files.
+   *
+   * Note: Don't add to the purely report-focused files. Those are files where
+   *    authors can focus on the info we give them, which they often miss in
+   *    the GitHub action.
+   */
+
   if ( success ) {
-    log.success({ type: `run`, code: `ALK0054`, pre: `Tests succeeded!` });
+    log.success({ code: `ALK0054`, context: `post_run`, },
+      `Tests succeeded!`
+    );
   } else {
-    log.error({ type: `run`, code: `ALK0055`, pre: `The test run ran into something unexpected. Look above for more details.` });
+    // Don't want to throw error here, so don't pass error object
+    log.warn({ code: `ALK0055`, context: `post_run`, },
+      `The tests ran into something unexpected. See warnings and errors above.`
+    );
   }
   // Custom exit code. May overlap with other systems.
   // Best info I've found via stack overflow: https://tldp.org/LDP/abs/html/exitcodes.html
   const exitCode = success ? 0 : 50;
   process.exitCode = exitCode;
 
+  /** TODO:
+   * randomly generated test file cleanup
+   * 1. Generate files into the sources folder
+   * 2. copy the randomly generated files into the artifacts folder
+   * 3. MVP: delete the randomly generated files from the sources folder
+   * 4. post MVP: let the author keep the randomly generated tests in the
+   *    sources folder and make a PR with them
+   * */
+
+  /**
+   * Loop through sources folders
+   *   If there are generated files in the generated files folder(s)
+   *     delete that folder from the sources folders where we found them
+   * */
+
   // This is hardcoded information from `provide_config` above.
   // This code isn't used for anything other than detecting and removing color codes.
   let summary_file_name = SUMMARY_FILENAME;
-  fs.readFile(summary_file_name, 'utf8', (err, text) => {
-    if (err) {
+  fs.readFile(summary_file_name, 'utf8', (read_error, text) => {
+    if ( read_error ) {
       // Something else will probably show an error that's more relevant
-      log.info({ type: `run`, code: `ALK0056`, pre: `Failed to read cucumber report`, data: err });
+      log.warn({ code: `ALK0056`, context: `post_run error`, },
+        `Failed to read cucumber report`, read_error
+      );
       return;
     }
 
@@ -134,20 +184,75 @@ function build_config( command_args ) {
     // https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797#colors--graphics-mode
     text = text.replace(/\x1b\[[0-9][0-9]?[0-9]?m/g, '');
 
-    // Put it in the correct file in the correct folder
-    let artifacts_path = session_vars.get_artifacts_path_name();
-    try {
-      fs.appendFileSync( `${ artifacts_path }/${ log.debug_log_file }`, `\n\n${text}`);
-    } catch ( error ) {
-      log.info({ type: `run`, code: `ALK0182`, pre: `Something probably went wrong earlier. Look above for more details, but here is more information just in case: ALKiln was unable to write to ${ artifacts_path }/${ log.debug_log_file }.`, data: error });
-    }
     try {
-      // Add to a unexpected results file when tests themselves fail
+      // Add to the debug and non-passed test output files
       if ( exitCode === 50 ) {
-        fs.appendFileSync( `${ artifacts_path }/${ log.unexpected_filename }`, `\n\n${ text }` );
+        // Save only non-passing test output to cut out cruft.
+        // Our reports save only non-passing tests to this file.
+        log.debug({ icon: `🔎`, code: `ALK0216`, context: `post_run`, level: `warn` },
+          `\n\n`, text
+        );
+      } else {
+        log.debug({ code: `ALK0225`, context: `post_run`, },
+          `\n\n`, text
+        );
       }
-    } catch ( error ) {
-      log.info({ type: `run`, code: `ALK0181`, pre: `Something probably went wrong earlier. Look above for more details, but here is more information just in case: ALKiln was unable to write to ${ artifacts_path }/${ log.unexpected_filename }.`, data: error });
-    }
+
+      /** Include debug info at the bottom of the unexpected results file if
+       *  needed. Avoid creating the file if its not necessary. */
+      let temp_debug_unexpected_content = ``;
+      try {
+        temp_debug_unexpected_content = fs.readFileSync(`${ log.path }/${ log.temp_unexpected_debug_log_filename }`);
+      } catch ( ignore_err ) { /* Missing debug info is ok */ }
+
+      if ( temp_debug_unexpected_content !== `` ) {
+        // Add spacing before the debug content if file already has content
+        try {
+          fs.readFileSync(`${ log.path }/${ log.unexpected_filename }`);  // Does it have contents?
+          fs.appendFileSync(`${ log.path }/${ log.unexpected_filename }`, `\n\n\n\n\n` );
+        } catch ( ignore_err ) { /* Missing unexpected file is ok */ }
+
+        // Add the heading for debug content
+        fs.appendFileSync( `${ log.path }/${ log.unexpected_filename }`,
+`≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
+🐛        Full DEBUG info (some repeated content)        🐛
+≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\n\n`
+        );
+        // Add the debug content itself
+        fs.appendFileSync(`${ log.path }/${ log.unexpected_filename }`, temp_debug_unexpected_content );
+      }
+
+    } catch ( writing_cucumber_error ) {
+      let code = `ALK0182`;
+      let context = `post_run error`
+      let msg = `Something probably went wrong earlier. See warnings and errors above. Skipped writing to ${ log.path }/${ log.debug_log_filename }.`;
+      try {
+        log.warn({ code, context, }, msg, writing_cucumber_error );
+      } catch ( all_writing_error ) {
+        console.warn( `🔎 ${ code } ${ context } WARNING ${ Date.now() }: ${ msg }` );
+        console.warn( writing_cucumber_error );
+        console.warn( all_writing_error );
+      }
+
+    }  // ends try writing to debug files
+
+    return;
   });
-})();
+}
+
+
+// 1. session_vars - make sure all the required env vars exist
+session_vars.validateEnvironment();
+
+// 2. Prepare logs
+// 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: `run` });
+
+// 3. Prep the sources paths to find .feature files
+let sources_paths = set_sources_paths({ log });
+
+// 4. run
+main();

package/lib/scope.js

@@ -13,14 +13,12 @@ const pdf_reader = require('./utils/pdf_reader');
 const session_vars = require('./utils/session_vars');
 const get_base_interview_url = require(`./docassemble/get_base_interview_url`);
 const time = require('./utils/time');
-const log = require('./utils/log');
 const { waitForTimeout } = require('./utils/time');
 const files = require('./utils/files' );
 const da_api = require('./docassemble/docassemble_api_interface');
 const wrapPromiseWithTimeout = require('./cucumber_8_shim');
 const reports = require(`./utils/reports`);
 
-
 let ordinal_to_integer = {
   only: 0, first: 0, second: 1, third: 2, fourth: 3, fifth: 4,
   sixth: 5, seventh: 6, eighth: 7, ninth: 8, tenth: 9,
@@ -84,10 +82,16 @@ let toBase64 = function ( utf8_str, exclude_padding=true) {
 
 let proxies_regex = /(\bx\.)|(\bx\[)|(\[[ijklmn]\])/g;
 let da_base64_regex = /^[A-Za-z0-9+/]+$/;
+let log = null;
 
 module.exports = {
   trigger_not_needed_flag: `ALKiln: no trigger variable needed`,
 
+
+  set_log: function ({ log_obj }) {
+    log = log_obj;
+  },
+
   getSafeScenarioBaseFilename: async function( scope, { scenario }) {
     /** Return a string that's safe to be a filename. Include the Scenario
     *    description and tags.
@@ -514,13 +518,17 @@ module.exports = {
   },
 
   continue_button_selector: `fieldset.da-field-buttons button[type="submit"].btn-primary`,
+  continue_button_selector_backup: `.da-fieldset.da-field-buttons button[type="submit"].btn-primary`,
   signature_selector: `fieldset .dasigsave`,
+  signature_selector_backup: `.da-fieldset .dasigsave`,
   continue: async function ( scope ) {
     /* Presses whatever button it finds that might lead to the next page. */
     // Any selectors I find seem somewhat precarious.
     let elem = await Promise.race([
       scope.page.waitForSelector(scope.continue_button_selector),  // other pages (this is the most consistent way)
+      scope.page.waitForSelector(scope.continue_button_selector_backup),
       scope.page.waitForSelector(scope.signature_selector),  // signature page
+      scope.page.waitForSelector(scope.signature_selector_backup),
     ]);
     await elem.evaluate( el => { return el.className });
     // Waits for navigation or user error
@@ -540,9 +548,11 @@ module.exports = {
     // <button type="submit" class="btn btn-da btn-danger" name="X211bHRpcGxlX2Nob2ljZQ" value="0">exit</button>
     // `buttons:` can be used in question blocks as choices
     let regular = await scope.page.$(scope.continue_button_selector);
+    let regular_backup = await scope.page.$(scope.continue_button_selector_backup);
     let signature = await scope.page.$(scope.signature_selector);
+    let signature_backup = await scope.page.$(scope.signature_selector_backup);
 
-    return regular !== null || signature !== null;
+    return regular !== null || regular_backup !== null || signature !== null || signature_backup !== null;
 
   },  // Ends scope.continue_exists()
 
@@ -692,7 +702,7 @@ module.exports = {
       });
       expect( load_result.error ).to.equal( '' );
     } else {
-      reports.addToReport(scope, { type: `row info`, code: `ALK0117`, value: `Successfully found the interview at "${ interview_url }"` });
+      reports.addToReport(scope, { type: `row info`, code: `ALK0117`, value: `Successfully found the interview` });
     }
 
     return scope.page;
@@ -711,19 +721,19 @@ module.exports = {
       if ( !scenario.interviews ) { scenario.interviews = {}; }
       if ( !scenario.interviews[ vars.uid ] ) {
         scenario.interviews[ vars.uid ] = vars;
-        log.debug({
-          code: `ALK0185`, type: `info`,
-          pre: `Saved new interview data. File path: ${ vars.i }. Session id: ${ vars.uid }.`
-        });
+        log.debug({ code: `ALK0185`, context: `session_id_etc` },
+          `Saved new interview data. File path: ${ vars.i }. Session id: ${ vars.uid }.`
+        );
       } else {
-        log.debug({
-          code: `ALK0186`, type: `info`,
-          pre: `Interview data already existed. File path: ${ vars.i }. Session id: ${ vars.uid }.`
-        });
+        log.debug({ code: `ALK0186`, context: `session_id_etc` },
+          `Interview data already existed. File path: ${ vars.i }. Session id: ${ vars.uid }.`
+        );
       }
       return vars;
     } else {
-      log.debug({ code: `ALK0187`, type: `info`, pre: `Found no interview data.` });
+      log.debug({ code: `ALK0187`, context: `session_id_etc` },
+        `Found no interview data.`
+      );
       return null;
     }
   },  // Ends scope.set_interview_session_data()
@@ -870,11 +880,9 @@ module.exports = {
       supported_table.push( result );
     }  // ends for every row
 
-    log.debug({
-      code: `ALK0122`,
-      type: `info`,
-      pre: `scope.normalizedTable():\n ${JSON.stringify( supported_table )}`
-    });
+    log.debug({ code: `ALK0122`, context: `table`, },
+      `scope.normalizedTable():`, supported_table
+    );
 
     return supported_table;
   },  // Ends scope.normalizeTable()
@@ -916,7 +924,7 @@ module.exports = {
     // All the different types of fields
     // buttons, canvases, inputs of all kinds, selects (dropdowns), textareas. Are there more?
     // Will deal with `option` once inside `select`
-    let all_nodes = $( `#dasigpage, fieldset button, .daquestionactionbutton, fieldset input, .da-form-group input, .da-form-group select, form select, .da-form-group textarea` );
+    let all_nodes = $( `#dasigpage, fieldset button, .da-fieldset button, .daquestionactionbutton, fieldset input, da-fieldset input, .da-form-group input, .da-form-group select, form select, .da-form-group textarea` );
     for ( let node of all_nodes ) {
       // Decision: Do not abstract the below. There's too much data to pass around for it to make sense
       let $node = $( node );
@@ -1024,11 +1032,9 @@ module.exports = {
       fields.push( field_data );
     }  // ends for every node
 
-    log.debug({
-      code: `ALK0124`,
-      type: `info`,
-      pre: `page fields:\n${ JSON.stringify( fields )}`
-    });
+    log.debug({ code: `ALK0124`, context: `page fields`, },
+      fields
+    );
     return fields;
   },  // Ends scope.getAllFields()
 
@@ -1078,11 +1084,9 @@ module.exports = {
     /* Return variable names and values combined in ways that can
     * try to match table rows. Tables can have two properties:
     * variable name and value. */
-    log.debug({
-      code: `ALK0126`,
-      type: `info`,
-      pre: `scope.getPossibleTableRowMatchers() var_names: ${JSON.stringify(var_names)} values: ${JSON.stringify(values)}`
-    });
+    log.debug({ code: `ALK0126`, context: `matching`, },
+      `scope.getPossibleTableRowMatchers() var_names:`, var_names, `values:`, values
+    );
     let possible_table_rows = [];
     for ( let var_name of var_names ) {
       // Inputs like textareas don't have values
@@ -1557,17 +1561,13 @@ module.exports = {
       reports.addToReport(scope, { type: `warning`, code: `ALK0130`, value: multiple_matches_msg });
     }
 
-    log.debug({
-      code: `ALK0131`,
-      type: `info`,
-      pre: `final_matching_rows:\n${JSON.stringify( final_matching_rows )}`
-    });
+    log.debug({ code: `ALK0131`, context: `matching`, },
+      `final_matching_rows:`, final_matching_rows
+    );
     if ( final_matching_rows.length == 0) {
-      log.debug({
-        code: `ALK0132`,
-        type: `info`,
-        pre: `field:\n${JSON.stringify( field )}`
-      });
+      log.debug({ code: `ALK0132`, context: `matching`, },
+        `0 matching rows. Field:`, field
+      );
     }
 
     return final_matching_rows;
@@ -1653,11 +1653,9 @@ module.exports = {
 
   get_handle_from_field: async function ( scope, { field }) {
     /** Get the element's puppeteer handle using the field's selector. */
-    log.debug({
-      code: `ALK0133`,
-      type: `info`,
-      pre: `scope.get_handle_from_field() field.selector: ${JSON.stringify(field.selector)}`
-    });
+    log.debug({ code: `ALK0133`, },
+      `scope.get_handle_from_field() field.selector:`, field.selector
+    );
     let handle = await scope.page.evaluateHandle(( selector ) => {
       let elem = document.querySelector( selector );
       // If the element has a sibling that's a label, we need to
@@ -2120,6 +2118,38 @@ module.exports = {
     // await scope.page.mouse.move(1, 1);  // Too big? Wait a while before drawing?
     await scope.page.mouse.up();
   },
+  
+  get_page_id: async function ( scope ) {
+    /** Return the current page's docassemble `question` block ID or `null`
+     *
+     * Note: The ID is already sanitized by docassemble.
+     *
+     * @param {object} scope - Tests state object
+     * @param {object} scope.page - puppeteerjs page object
+     *
+     * @returns {null | string}
+     * */
+    let question_id_match = await scope.page.$eval(`body`, function (elem) {
+      return elem.className.match(/question-([^ ]+)/);
+    });
+    if ( question_id_match !== null ) {
+      return question_id_match[ 1 ];
+    }
+    return null;
+  },
+
+  to_docassemble_sanitized_id: function ( risky_id ) {
+    /** Return a version of `risky_id` that's sanitized the same way docassemble
+     *    sanitizes its IDs to turn them into HTML class names in python:
+     *      re.sub(r'[^A-Za-z0-9]+', '-', interview_status.question.id.lower())
+     *    (reference needed)
+     *
+     * @param {string} risky_id - The un-sanitized id
+     *
+     * @returns {string} - Sanitized id
+     * */
+    return risky_id.toLowerCase().replace(/[^A-Za-z0-9]+/g, '-');
+  },
 
   examinePageID: async function ( scope, question_id = '' ) {
     /* Looks for a sanitized version of the question id as it's written
@@ -2169,7 +2199,9 @@ module.exports = {
     * @param ensure_all_vars_used {bool} [false] = Default false. If true, errors if any
     *     object in var_data is not used during running of this function.
     */
-    log.debug({ type: `plain`, pre: `~~~~~~~~~~~~~~ scope.setFields() ~~~~~~~~~~~~~~` });
+    log.debug({ code: `ALK0221`, before: `~~~~~~~~~~~~~~\n`, },
+      `scope.setFields()`
+    );
 
     // Only record the page id once for each page to which we navigate
     let { id } = await scope.examinePageID( scope, 'none to match' );
@@ -2213,8 +2245,7 @@ module.exports = {
           // Accumulate number of times this row was used. Esp important for `.target_number`
           await scope.increment_row_use( scope, { row: row_used });
 
-          process.stdout.write(`\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
-
+          log.stdout({}, `\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
         }
       }  // ends for every non-submit-button field on the page
     }  // ends while fields are still being set
@@ -2259,7 +2290,7 @@ module.exports = {
           // }
 
           did_navigate = true;
-          process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button successfully
+          log.stdout({}, `\x1b[36m${ 'v' }\x1b[0m`);  // pressed button successfully
           break;
 
         }  // ends if row_used
@@ -2306,7 +2337,7 @@ module.exports = {
       // }
 
       did_navigate = true;
-      process.stdout.write(`\x1b[36m${ '>' }\x1b[0m`);  // continued successfully
+      log.stdout({}, `\x1b[36m${ '>' }\x1b[0m`);  // continued successfully
     }  // ends if !did_navigate && ensure_navigation
 
     if ( did_navigate && scope.check_all_for_a11y ) {
@@ -2635,6 +2666,7 @@ module.exports = {
 
     let fullPage = true;
     let signature_elem = await scope.page.$(scope.signature_selector);
+    signature_elem = signature_elem || await scope.page.$(scope.signature_selector_backup);
     if ( signature_elem !== null ) {
       fullPage = false;
     }
@@ -3102,36 +3134,30 @@ module.exports = {
       let redirect_promise = scope.page.waitForResponse(function ( response ) {
         return response.status() === 302;
       }, { signal: controller.signal })
-      .catch(( error ) => {
-        log.debug({
-          code: `ALK0204`, type: `info`,
-          pre: `302 sign-in wait error: ${ error.name }`,
-          data: error,
-        });
+      .catch(( catch_info ) => {
+        log.debug({ code: `ALK0204`, context: `nav`, },
+          `302 sign-in wait catch error:`, catch_info.name, catch_info,
+        );
       });
 
       // Invalid credentials, no navigation, no sign in
       let wrong_sign_in_promise = scope.page.waitForResponse(function ( response ) {
         return response.status() >= 200 && response.status() < 300 && response.url().includes(`/sign-in`);
       }, { signal: controller.signal })
-      .catch(( error ) => {
-        log.debug({
-          code: `ALK0205`, type: `info`,
-          pre: `200s sign-in wait error: ${ error.name }`,
-          data: error,
-        });
+      .catch(( catch_info ) => {
+        log.debug({ code: `ALK0205`, context: `nav`, },
+          `200s sign-in wait catch error:`, catch_info.name, catch_info,
+        );
       });
 
       // System error
       let error_promise = scope.page.waitForResponse(function ( response ) {
         return response.status() >= 500 && response.status() < 600;
       }, { signal: controller.signal })
-      .catch(( error ) => {
-        log.debug({
-          code: `ALK0206`, type: `info`,
-          pre: `500s sign-in wait error: ${ error.name }`,
-          data: error,
-        });
+      .catch(( catch_info ) => {
+        log.debug({ code: `ALK0206`, context: `nav`, },
+          `500s sign-in wait catch error:`, catch_info.name, catch_info,
+        );
       });
 
       let click_promise = elem.click();  // MUST complete
@@ -3150,10 +3176,9 @@ module.exports = {
       // Clean up unresolved promises
       controller.abort();
 
-      log.debug({
-        code: `ALK0208`, type: `info`,
-        pre: `Sign-in winner:`, data: winner,
-      });
+      log.debug({ code: `ALK0208`, context: `nav` },
+        `Sign-in winner:`, winner
+      );
 
       return winner;
     },
@@ -3176,7 +3201,7 @@ module.exports = {
         } else {
           // Try to give a random answer for that element tag
           await scope.set_random_input_for[ field.tag ]( scope, { field: field });
-          process.stdout.write(`\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
+          log.stdout({}, `\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
         }
 
       }  // End for all page fields
@@ -3212,11 +3237,10 @@ module.exports = {
       }
       if (field == null) {
         // Just skip it? Shouldn't happen but has before. Dig in more
-        log.debug({
-          code: `ALK0164`,
-          type: `info`,
-          pre: `A random button field choice was null. These were the fields to choose from:\n${ JSON.stringify(fields, null, 2) }`,
-        });
+        log.debug({ code: `ALK0164`, context: `random`, },
+          `A random button field choice was null. These were the fields to choose from:`,
+          fields
+        );
         return;
       }
       let handle = await scope.get_handle_from_field( scope, { field: field });