@suffolklitlab/alkiln 5.13.3 → 5.13.4

package/lib/steps.js

@@ -5,6 +5,7 @@ const {
   Given,
   After,
   Before,
+  AfterStep,
   BeforeAll,
   AfterAll,
   setDefaultTimeout //,
@@ -18,7 +19,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 +83,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 +98,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) {
@@ -396,11 +400,9 @@ 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.
@@ -972,7 +974,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();
@@ -1263,11 +1265,22 @@ 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({ 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 +1310,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 +1408,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 +1430,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 +1502,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 +1515,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 +1536,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
+  );
 
 });