@suffolklitlab/alkiln 5.12.0-delete6 → 5.13.0-logs1

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,29 @@ 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.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.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) => {
 
-  // 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 +399,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.
@@ -650,7 +651,7 @@ Then('I arrive at the next page', async () => {  // √
 // Link observations have the 'Escape' button link in mind
 Then('I should see the link {string}', async ( linkText ) => {  // √
   /* Loosely match link visible text. Should probably deprecate this. */
-  let [link] = await scope.page.$x(`//a[contains(text(), "${linkText}")]`);
+  let [link] = await scope.page.$$(`xpath/.//a[contains(text(), "${linkText}")]`);
 
   let msg = `Cannot find a link with the text "${ linkText }".`;
   if ( !link ) { reports.addToReport(scope, { type: `error`, code: `ALK0079`, value: msg }); }
@@ -672,7 +673,7 @@ Then('I should see the link to {string}', async ( url ) => {  // √
 
 Then(/the "([^"]+)" link leads to "([^"]+)"/, async (linkText, expected_url) => {  // √
   /* Find link by its visible text and where it leads. */
-  let [link] = await scope.page.$x(`//a[contains(text(), "${linkText}")]`);
+  let [link] = await scope.page.$$(`xpath/.//a[contains(text(), "${linkText}")]`);
   // TODO: Possibly add a check here for the link text, though note this
   // Step is not currently supported.
 
@@ -687,7 +688,7 @@ Then(/the "([^"]+)" link leads to "([^"]+)"/, async (linkText, expected_url) =>
 });
 
 Then(/the "([^"]+)" link opens in (a new window|the same window)/, async (linkText, which_window) => {  // √
-  let [link] = await scope.page.$x(`//a[contains(text(), "${linkText}")]`);
+  let [link] = await scope.page.$$(`xpath/.//a[contains(text(), "${linkText}")]`);
 
   let prop_obj = await link.getProperty('target');
   let target = await prop_obj.jsonValue();
@@ -972,7 +973,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 +1264,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;
@@ -1296,11 +1308,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 ) {
 
@@ -1396,8 +1406,11 @@ 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
+      );
+      // Temp for debugging new log output
+      expect( expected_status_err_msg ).to.equal(`🤕 ${ code } ERROR: ${ msg }`);
     }
   }
   scope.expected_status = null;  // reset for next Scenario
@@ -1417,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
@@ -1481,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
@@ -1493,26 +1515,37 @@ 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.`
+      );
     }
   }
 
-  // Handle all the accumulated errors
-  let errors = []
-  if ( !expected_status_was_met ) { errors.push( expected_status_err_msg ); }
-  if ( !signout_succeeded ) { errors.push( signout_error_msg ); }
-  if ( errors.length > 0 ) {
-    throw new Error( `${errors.join( errors, '\n')}` );
-  }
+  // Collect all the relevant special errors
+  let internal_errors = []
+  if ( !expected_status_was_met ) { internal_errors.push( expected_status_err_msg ); }
+  if ( !signout_succeeded ) { internal_errors.push( signout_error_msg ); }
 
   // Theoretically, we should never get here:
   // If everything else worked, if we need to force an internal test failure
   if ( need_to_force_failed_status ) {
-    throw new Error( `🤕 ${force_failure_code} unreachable ERROR: ${force_failure_msg}` );
+    if ( internal_errors.length > 0 ) {
+      // Handle all the accumulated errors
+      throw new Error( `${internal_errors.join( internal_errors, '\n')}` );
+    }
+    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
+    );
   }
 
   // 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
+  );
 
 });
 

package/lib/utils/files.js

@@ -22,18 +22,20 @@ files.readable_date = function() {
 };  // Ends files.readable_date()
 
 files.make_artifacts_folder = function (folder_name) {
-  /** 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.
-  */
+  /** 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.
+   * */
   if (folder_name) {
     folder_name = safe_filename( folder_name );
   } else {
     folder_name = `alkiln-${ files.readable_date() }`
   }
 
-  fs.mkdirSync( folder_name );
+  // `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 });
   return folder_name;
 };  // Ends files.make_artifacts_folder()