@suffolklitlab/alkiln 5.13.2 → 5.13.4

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
@@ -2169,7 +2167,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 +2213,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 +2258,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 +2305,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 +2634,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 +3102,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 +3144,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 +3169,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 +3205,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 });

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
+  );
 
 });