@suffolklitlab/alkiln 5.13.0-logs3 → 5.13.1

package/lib/scope.js

@@ -13,13 +13,14 @@ 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 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,
@@ -83,16 +84,10 @@ 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.
@@ -697,7 +692,7 @@ module.exports = {
       });
       expect( load_result.error ).to.equal( '' );
     } else {
-      reports.addToReport(scope, { type: `row info`, code: `ALK0117`, value: `Successfully found the interview` });
+      reports.addToReport(scope, { type: `row info`, code: `ALK0117`, value: `Successfully found the interview at "${ interview_url }"` });
     }
 
     return scope.page;
@@ -716,19 +711,19 @@ module.exports = {
       if ( !scenario.interviews ) { scenario.interviews = {}; }
       if ( !scenario.interviews[ vars.uid ] ) {
         scenario.interviews[ vars.uid ] = vars;
-        log.debug({ code: `ALK0185`, context: `session_id_etc` },
-          `Saved new interview data. File path: ${ vars.i }. Session id: ${ vars.uid }.`
-        );
+        log.debug({
+          code: `ALK0185`, type: `info`,
+          pre: `Saved new interview data. File path: ${ vars.i }. Session id: ${ vars.uid }.`
+        });
       } else {
-        log.debug({ code: `ALK0186`, context: `session_id_etc` },
-          `Interview data already existed. File path: ${ vars.i }. Session id: ${ vars.uid }.`
-        );
+        log.debug({
+          code: `ALK0186`, type: `info`,
+          pre: `Interview data already existed. File path: ${ vars.i }. Session id: ${ vars.uid }.`
+        });
       }
       return vars;
     } else {
-      log.debug({ code: `ALK0187`, context: `session_id_etc` },
-        `Found no interview data.`
-      );
+      log.debug({ code: `ALK0187`, type: `info`, pre: `Found no interview data.` });
       return null;
     }
   },  // Ends scope.set_interview_session_data()
@@ -875,9 +870,11 @@ module.exports = {
       supported_table.push( result );
     }  // ends for every row
 
-    log.debug({ code: `ALK0122`, context: `table`, },
-      `scope.normalizedTable():`, supported_table
-    );
+    log.debug({
+      code: `ALK0122`,
+      type: `info`,
+      pre: `scope.normalizedTable():\n ${JSON.stringify( supported_table )}`
+    });
 
     return supported_table;
   },  // Ends scope.normalizeTable()
@@ -1027,9 +1024,11 @@ module.exports = {
       fields.push( field_data );
     }  // ends for every node
 
-    log.debug({ code: `ALK0124`, context: `page fields`, },
-      fields
-    );
+    log.debug({
+      code: `ALK0124`,
+      type: `info`,
+      pre: `page fields:\n${ JSON.stringify( fields )}`
+    });
     return fields;
   },  // Ends scope.getAllFields()
 
@@ -1079,9 +1078,11 @@ 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`, context: `matching`, },
-      `scope.getPossibleTableRowMatchers() var_names:`, var_names, `values:`, values
-    );
+    log.debug({
+      code: `ALK0126`,
+      type: `info`,
+      pre: `scope.getPossibleTableRowMatchers() var_names: ${JSON.stringify(var_names)} values: ${JSON.stringify(values)}`
+    });
     let possible_table_rows = [];
     for ( let var_name of var_names ) {
       // Inputs like textareas don't have values
@@ -1556,13 +1557,17 @@ module.exports = {
       reports.addToReport(scope, { type: `warning`, code: `ALK0130`, value: multiple_matches_msg });
     }
 
-    log.debug({ code: `ALK0131`, context: `matching`, },
-      `final_matching_rows:`, final_matching_rows
-    );
+    log.debug({
+      code: `ALK0131`,
+      type: `info`,
+      pre: `final_matching_rows:\n${JSON.stringify( final_matching_rows )}`
+    });
     if ( final_matching_rows.length == 0) {
-      log.debug({ code: `ALK0132`, context: `matching`, },
-        `0 matching rows. Field:`, field
-      );
+      log.debug({
+        code: `ALK0132`,
+        type: `info`,
+        pre: `field:\n${JSON.stringify( field )}`
+      });
     }
 
     return final_matching_rows;
@@ -1648,9 +1653,11 @@ 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`, },
-      `scope.get_handle_from_field() field.selector:`, field.selector
-    );
+    log.debug({
+      code: `ALK0133`,
+      type: `info`,
+      pre: `scope.get_handle_from_field() field.selector: ${JSON.stringify(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
@@ -2162,9 +2169,7 @@ 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({ code: `ALK0221`, before: `~~~~~~~~~~~~~~\n`, },
-      `scope.setFields()`
-    );
+    log.debug({ type: `plain`, pre: `~~~~~~~~~~~~~~ scope.setFields() ~~~~~~~~~~~~~~` });
 
     // Only record the page id once for each page to which we navigate
     let { id } = await scope.examinePageID( scope, 'none to match' );
@@ -2208,7 +2213,8 @@ module.exports = {
           // Accumulate number of times this row was used. Esp important for `.target_number`
           await scope.increment_row_use( scope, { row: row_used });
 
-          log.stdout({}, `\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
+          process.stdout.write(`\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
@@ -2253,7 +2259,7 @@ module.exports = {
           // }
 
           did_navigate = true;
-          log.stdout({}, `\x1b[36m${ 'v' }\x1b[0m`);  // pressed button successfully
+          process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button successfully
           break;
 
         }  // ends if row_used
@@ -2300,7 +2306,7 @@ module.exports = {
       // }
 
       did_navigate = true;
-      log.stdout({}, `\x1b[36m${ '>' }\x1b[0m`);  // continued successfully
+      process.stdout.write(`\x1b[36m${ '>' }\x1b[0m`);  // continued successfully
     }  // ends if !did_navigate && ensure_navigation
 
     if ( did_navigate && scope.check_all_for_a11y ) {
@@ -3057,30 +3063,36 @@ module.exports = {
       let redirect_promise = scope.page.waitForResponse(function ( response ) {
         return response.status() === 302;
       }, { signal: controller.signal })
-      .catch(( catch_info ) => {
-        log.debug({ code: `ALK0204`, context: `nav`, },
-          `302 sign-in wait catch error:`, catch_info.name, catch_info,
-        );
+      .catch(( error ) => {
+        log.debug({
+          code: `ALK0204`, type: `info`,
+          pre: `302 sign-in wait error: ${ error.name }`,
+          data: error,
+        });
       });
 
       // 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(( catch_info ) => {
-        log.debug({ code: `ALK0205`, context: `nav`, },
-          `200s sign-in wait catch error:`, catch_info.name, catch_info,
-        );
+      .catch(( error ) => {
+        log.debug({
+          code: `ALK0205`, type: `info`,
+          pre: `200s sign-in wait error: ${ error.name }`,
+          data: error,
+        });
       });
 
       // System error
       let error_promise = scope.page.waitForResponse(function ( response ) {
         return response.status() >= 500 && response.status() < 600;
       }, { signal: controller.signal })
-      .catch(( catch_info ) => {
-        log.debug({ code: `ALK0206`, context: `nav`, },
-          `500s sign-in wait catch error:`, catch_info.name, catch_info,
-        );
+      .catch(( error ) => {
+        log.debug({
+          code: `ALK0206`, type: `info`,
+          pre: `500s sign-in wait error: ${ error.name }`,
+          data: error,
+        });
       });
 
       let click_promise = elem.click();  // MUST complete
@@ -3099,9 +3111,10 @@ module.exports = {
       // Clean up unresolved promises
       controller.abort();
 
-      log.debug({ code: `ALK0208`, context: `nav` },
-        `Sign-in winner:`, winner
-      );
+      log.debug({
+        code: `ALK0208`, type: `info`,
+        pre: `Sign-in winner:`, data: winner,
+      });
 
       return winner;
     },
@@ -3124,7 +3137,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 });
-          log.stdout({}, `\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
+          process.stdout.write(`\x1b[36m${ '*' }\x1b[0m`);  // assumes var was set if no error occurred
         }
 
       }  // End for all page fields
@@ -3160,10 +3173,11 @@ module.exports = {
       }
       if (field == null) {
         // Just skip it? Shouldn't happen but has before. Dig in more
-        log.debug({ code: `ALK0164`, context: `random`, },
-          `A random button field choice was null. These were the fields to choose from:`,
-          fields
-        );
+        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) }`,
+        });
         return;
       }
       let handle = await scope.get_handle_from_field( scope, { field: field });

package/lib/steps.js

@@ -5,7 +5,6 @@ const {
   Given,
   After,
   Before,
-  AfterStep,
   BeforeAll,
   AfterAll,
   setDefaultTimeout //,
@@ -19,7 +18,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`);
@@ -83,9 +82,7 @@ let click_with = {
   pc: 'click',
 };
 
-let log = null;
-
-BeforeAll(async function() {
+BeforeAll(async () => {
   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.
@@ -98,29 +95,29 @@ BeforeAll(async function() {
   // Store path names for files and docs created for the tests
   scope.paths = {};
 
-  // // 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.
+  // TODO: figure out how to test file and folder creation stuff,
+  // especially when setup is excluded from the flow.
 
-  // 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 });
+  // 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 );
 
-  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.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, "" );
 
   reports.create( scope );
 });
 
 Before(async (scenario) => {
 
-  // Start the running "progress bar" for the Scenario
-  log.stdout({}, `\nScenario: ${ scenario.pickle.name }: `);
+  // 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 }: `);
 
   // Create browser, which can't be created in BeforeAll() where .driver doesn't exist for some reason
   if (!scope.browser) {
@@ -399,9 +396,11 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
             from_story_table: true,
           });
 
-          log.debug({ code: `ALK0061`, context: `table`, },
-            `Rows, including special rows:`, ensured_var_data
-          );
+          log.debug({
+            type: `info`,
+            code: `ALK0061`,
+            pre: `Rows, including special rows:, ${JSON.stringify( 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.
@@ -973,7 +972,7 @@ When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { tim
           }  // ends if !has_content
 
           if ( buttons_exist ) {
-            log.stdout({}, `\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
+            process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
           }
 
           resolve();
@@ -1264,22 +1263,11 @@ 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`); }
-});
-
 After(async function(scenario) {
 
   // Log errors
   if ( scenario.result.message ) {
-    log.debug({ code: `ALK0091`, context: `scenario`, },
-      scenario.result.message
-    );
+    log.debug({ type: `info`, code: `ALK0091`, pre: `cucumber error: ${ scenario.result.message }` }); //, verbose: true });
   }
 
   let changeable_test_status = scenario.result.status;
@@ -1308,9 +1296,11 @@ After(async function(scenario) {
   reports.saveFinalScenarioData( scope, { status: changeable_test_status });
 
   if (changeable_test_status !== `PASSED`) {
-    log.debug({ code: `ALK0094`, level: `warn`, },
-      `Non-passed status occurred while running test: ${ changeable_test_status }`
-    );
+    log.debug({
+      type: `error`,
+      code: `ALK0094`,
+      pre: `Non-passed status occurred while running test: ${changeable_test_status}`,
+    });
 
     if ( scope.page ) {
 
@@ -1406,11 +1396,8 @@ After(async function(scenario) {
           + `Expected status: ${scope.expected_status}. `
           + `See the report for details.`;
       let code = `ALK0099`;
-      expected_status_err_msg = log.debug({ code: code, level: `error`, },
-        msg
-      );
-      // Temp for debugging new log output
-      expect( expected_status_err_msg ).to.equal(`🤕 ${ code } ERROR: ${ msg }`);
+      log.debug({ type: `error`, code: code, pre: msg, })
+      expected_status_err_msg = `🤕 ${ code } ERROR: ${ msg }`
     }
   }
   scope.expected_status = null;  // reset for next Scenario
@@ -1430,25 +1417,17 @@ 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.
-    // TODO: Should we move this to where the error is thrown?
-    log.debug({ code: force_failure_code, level: `error`, },
-      force_failure_msg
-    );
+    log.debug({
+      type: `error`,
+      code: force_failure_code,
+      pre: 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
@@ -1502,10 +1481,9 @@ 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.debug({ code: `ALK0197`, context: `internal`, level: `warn`, }
-          `The API key can see ${ visible_keys.length } interviews that were not deleted:`,
-          visible_keys
-        );
+        log.info({ type: `internal warning`, code: `ALK0197`,
+          pre: `The API key can see ${ visible_keys.length } interviews that were not deleted: ${ visible_keys.join( ', ' ) }`
+        });
       }
     } catch ( error ) {
       // Deleting interviews is nice, but not non-critical. Don't bother the
@@ -1515,9 +1493,7 @@ 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.debug({ code: `ALK0198`, context: `internal`, level: `warn`, error },
-        `Cleaning up interviews incomplete, but unimportant.`
-      );
+      log.info({ type: `internal warning`, code: `ALK0198`, pre: `Error while cleaning up interviews.`, data: error });
     }
   }
 
@@ -1536,16 +1512,11 @@ After(async function(scenario) {
     throw new Error( `🤕 ${ force_failure_code } unreachable ERROR: ${ force_failure_msg }` );
 
   } else if ( internal_errors.length > 0 ) {
-    log.debug({ code: `ALK0203`, context: `internal`, level: `warn`, },
-      `There was no need to force failed status and yet there are error messages.`,
-      internal_errors
-    );
+    log.info({ type: `internal error`, code: `ALK0203`, pre: `No need to force failed status and yet there are error messages. ${ errors.join( errors, '\n') }` });
   }
 
   // Find the race condition.
-  log.debug({ code: `ALK0100`, context: `scenario`, },
-    `Scenario After() message:`, scenario.result.message
-  );
+  log.debug({ type: `cucumber`, code: `ALK0100`, verbose: true, pre: `Scenario AfterStep() message`, data: scenario.result.message });
 
 });
 

package/lib/utils/files.js

@@ -22,20 +22,18 @@ files.readable_date = function() {
 };  // Ends files.readable_date()
 
 files.make_artifacts_folder = function (folder_name) {
-  /** 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.
-   * */
+  /** Makes a folder in the root of the project, either with the given name
+  *   or with a default name.
+  * 
+  * Works for local development as well, unlike action.yml or the workflow file.
+  */
   if (folder_name) {
     folder_name = safe_filename( folder_name );
   } else {
     folder_name = `alkiln-${ files.readable_date() }`
   }
 
-  // `recursive` avoids errors if folder already exists
-  // https://nodejs.org/docs/latest-v18.x/api/fs.html#fspromisesmkdirpath-options
-  fs.mkdirSync( folder_name, { recursive: true });
+  fs.mkdirSync( folder_name );
   return folder_name;
 };  // Ends files.make_artifacts_folder()