@suffolklitlab/alkiln 5.7.0 → 5.8.1-feat2columns1

package/lib/steps.js

@@ -254,7 +254,7 @@ Given(/I (?:sign|log) ?(?:in)?(?:on)?(?:to the server)? with(?: the email)? "([^
   * I sign on with the email "USER1_EMAIL" and the password "USER1_PASSWORD" SECRETs
   * I log in with "USER1_EMAIL" and "USER1_PASSWORD"
   */
-  // Exiting the custom timeout happens in scope.tapElement() if needed
+  // `page` timeout will deal with custom timeout
   // Couldn't test the timeout for tapping the button because there's not
   // enough of a pause between initial navigation and pressing button.
   await scope.steps.sign_in( scope, {
@@ -341,6 +341,7 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
         try {
           let { question_has_id, id, id_matches } = await scope.examinePageID( scope );
 
+          // THIS FUNCTION ACTUALLY MATTERS
           // Add special rows. Basically, do weirder things.
           // TODO: Remove from_story_table - no longer needed if only called from in here
           let ensured_var_data = await scope.ensureSpecialRows( scope, {
@@ -352,8 +353,10 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
             console.log( `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.
           let error = await scope.setFields(scope, { var_data: ensured_var_data, id, ensure_navigation: true });
+
           if ( error.was_found ) { await scope.throwPageError( scope, { id: id }); }
           resolve();
         } catch ( err ) {
@@ -415,6 +418,123 @@ When(/^(?:the user gets)?(?:I get)? to ?(?:the)?(?: ?question)?(?: id)? "([^"]+)
   reports.addToReport(scope, { type: `note`, value: `` });
 });
 
+// When(/^foo id "([^"]+)"/, {timeout: -1}, async (target_id, raw_var_data) => {
+//   /* NO CUCUMBER TIMEOUT. Must handle timeout ourselves:
+//   * https://github.com/cucumber/cucumber-js/blob/master/docs/support_files/timeouts.md#disable-timeouts
+//   * Iterate in here to keep timeout reasonable */
+
+//   // Note: Why do we not just stop when we've used all the vars in the table or
+//   // reach the last var? Vars are not required to be given in sequence and pages that
+//   // have non-button fields don't usually have a var assigned to the 'continue' button.
+//   // Alternative: require vars even for 'continue' pages. Then in loop require at least one var
+//   // to be found on a page before hitting 'continue'. That requires detecting navigation because
+//   // pages with fields will not have a var for the continue button, so there will
+//   // still have to be some automatic continuing.
+//   // It also seems harsh, but more reliable.
+//   // Ask developers what they'd like.
+
+
+//   let supported_table = await scope.normalizeTable( scope, { raw_var_data });
+
+//   let { question_has_id, id, id_matches } = await scope.examinePageID( scope, target_id );
+//   // Until we reach the target page, hit an error, or time out (take too long)
+//   while ( !id_matches ) {
+//     let custom_timeout = new Promise(function( resolve, reject ) {
+
+//       // Set up the timeout that avoids infinite loops
+//       let on_page_timeout = async function() {
+
+//         let non_reload_report_msg = `The target id was "${ target_id }", but it took `
+//         + `too long to try to reach it (over ${ scope.timeout/1000/60 } min). The `
+//         + `test got stuck on "${ id }".`
+//         let error = non_reload_report_msg;
+//         await scope.handle_page_timeout_error( scope, { non_reload_report_msg, error });
+//       };  // Ends on_page_timeout()
+//       let page_timeout_id = setTimeout(on_page_timeout, scope.timeout);
+
+//       // self-invoke an anonymous async function so we don't have to
+//       // abstract the details of resolving and rejecting.
+//       // If we need to call recursively, signature function might look like:
+//       // func( scope, { resolve, reject, supported_table, page_timeout_id })
+//       // Maybe list of timeout and/or interval ids in state that can all be cleared at once?
+//       (async function() {
+//         try {
+//           let { question_has_id, id, id_matches } = await scope.examinePageID( scope );
+
+//           // Add special rows. Basically, do weirder things.
+//           // TODO: Remove from_story_table - no longer needed if only called from in here
+//           let ensured_var_data = await scope.ensureSpecialRows( scope, {
+//             var_data: supported_table,
+//             from_story_table: true,
+//           });
+
+//           if ( session_vars.get_debug() ) {
+//             console.log( `Rows, including special rows:`, JSON.stringify( ensured_var_data ));
+//           }
+
+//           // Some errors happen in there to be closer to the relevant code. We'd have to try/catch anyway.
+//           let error = await scope.setFields(scope, { var_data: ensured_var_data, id, ensure_navigation: true });
+//           if ( error.was_found ) { await scope.throwPageError( scope, { id: id }); }
+//           resolve();
+//         } catch ( err ) {
+//           let err_msg = `Error occurred when tried to answer fields on question "${ id }".`
+//           reports.addToReport( scope, { type: `error`, value: err_msg });
+//           // Throw error instead?
+//           reject( err );
+//         } finally {
+//           clearTimeout( page_timeout_id );  // prevent temporary hang at end of tests
+//         }
+//       })();
+//     });  // ends custom_timeout for setFields
+
+//     await custom_timeout;
+
+//     // Prep for next loop
+//     ({ question_has_id, id, id_matches } = await scope.examinePageID( scope, target_id ));
+
+//   }  // ends while !id_matches
+//   // Can anything unsatisfactory get through here?
+
+//   // Add report strings from supported table, not an altered one
+//   for ( let row of supported_table ) {
+//     row.report_str = `${ reports.convertToOriginalStoryTableRow(scope, { row_data: row }) }`;
+//   }
+//   // Sort into alphabetical order, as is recommended for writing story tables
+//   let sorted_rows = supported_table.sort( function ( row1, row2 ) {
+//     if( row1.report_str < row2.report_str ) { return -1; }
+//     if( row1.report_str > row2.report_str ) { return 1; }
+//     return 0;
+//   });
+
+//   // Add full used table to report so it can be copied if needed.
+//   // TODO: Should we/How do we get this in the final scenario report instead of here?
+//   reports.addToReport( scope, { type: `note`, value: `\n${ ' '.repeat(2) }Rows that got set:` });
+//   reports.addToReport( scope, { type: `step`, value: `${ ' '.repeat(4) }And I get to the question id "${ target_id }" with this data:` });
+//   reports.addToReport(scope, { type: `row`, value: `${ ' '.repeat(6) }| var | value | trigger |`, });
+//   let at_least_one_row_was_NOT_used = false;
+//   for ( let row of sorted_rows ) {
+//     if ( row.times_used > 0 ) {
+//       reports.addToReport(scope, { type: `row`, value: row.report_str, });
+//     } else {
+//       at_least_one_row_was_NOT_used = true;
+//     }
+//   }
+
+//   // Add unused rows if needed
+//   if ( at_least_one_row_was_NOT_used ) {
+//     reports.addToReport( scope, { type: `note`, value: `${ ' '.repeat(2) }Unused rows:` });
+//     for ( let row of sorted_rows ) {
+//       if ( row.times_used === 0 ) {
+//         reports.addToReport(scope, { type: `row`, value: row.report_str, });
+//       }
+//     }
+//   } else {
+//     reports.addToReport(scope, { type: `note`, value: `${ ' '.repeat(2) }All rows were used` });
+//   }
+
+//   reports.addToReport(scope, { type: `note`, value: `` });
+// });
+
 //#####################################
 //#####################################
 // Passive/Observational
@@ -745,24 +865,32 @@ When(/I tap to continue/i, { timeout: -1 }, async () => {
   // Any selectors for this seem somewhat precarious
   // No data will cause an automatic continue when `ensure_navigation` is true
 
-  // Exiting the custom timeout happens in scope.tapElement() where we can
+  // `page` timeout will deal with custom timeout
   // check if the server is reloading
   await scope.setFields( scope, { var_data: [], ensure_navigation: true });
 });
 
 When(/I tap the "([^"]+)" tab/i, { timeout: -1 }, async ( tabId ) => {
-  // Exiting the custom timeout happens in scope.tapElement() if needed
+  // `page` timeout will deal with custom timeout
   await scope.tapTab( scope, tabId );
 });
 
-When(/I tap the "([^"]+)" element$/i, { timeout: -1 }, async ( elemSelector ) => {
-  // Exiting the custom timeout happens in scope.tapElement() if needed
-  await scope.tapElementBySelector( scope, elemSelector, 2000 );
+When(/I tap the "([^"]+)" element(?: and go to (?:a new|the next) page)?$/i, { timeout: -1 }, async ( elemSelector ) => {
+  // `page` timeout will deal with custom timeout
+  await scope.tapSelectorToNavigate( scope, elemSelector, 2000 );
 });
 
-When(/I tap the "([^"]+)" element and wait ([0-9]+) second(?:s)?/i, { timeout: -1 }, async ( elemSelector, waitTime ) => {
-  // Exiting the custom timeout happens in scope.tapElement() if needed
-  await scope.tapElementBySelector( scope, elemSelector, waitTime * 1000 )
+When(/I tap the "([^"]+)" element and stay(?: on the same page)?$/i, { timeout: -1 }, async ( selector ) => {
+  // `page` timeout will deal with custom timeout
+  await scope.tapSelectorAndStay( scope, { selector });
+});
+
+When(/I tap the "([^"]+)" element and wait (?:for )?([0-9]+) second(?:s)?/i, { timeout: -1 }, async ( elemSelector, waitTime ) => {
+  // TODO: Why is it the developer can't just wait after the step?
+  // Also, this is always supposed to navigate, and that handles its own waiting.
+
+  // `page` timeout will deal with custom timeout
+  await scope.tapSelectorToNavigate( scope, elemSelector, waitTime * 1000 )
 });
 
 When(/I check the page for (?:accessibility|a11y) issues/i, {timeout: -1}, async () => {
@@ -967,7 +1095,7 @@ When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async (
   * 1. I set the var "benefits['SSI']" to "false"
   * 1. I set the variable "rent_interval" to "weekly"
   */
-  // Exiting the custom timeout happens in scope.tapElement() if needed
+  // `page` timeout will deal with custom timeout
   await scope.steps.set_regular_var( scope, var_name, answer )
 
 });
@@ -975,7 +1103,7 @@ When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async (
 When(/I set the var(?:iable)? "([^"]+)" to ?(?:the)? ?(?:GitHub)? secret "([^"]+)"/i, { timeout: -1 }, async ( var_name, set_to_env_name ) => {
   /* Set a non-story table variable to a secrete value. Same as the above, but reads the value from `process.env` */
   // This could theoretically tap an element, so
-  // exiting the custom timeout happens in scope.tapElement() if needed
+  // `page` timeout will deal with custom timeout
   await scope.steps.set_secret_var( scope, var_name, set_to_env_name )
 });
 
@@ -995,7 +1123,7 @@ Then(/I upload "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( filenames, var_
 
 When('I tap the defined text link {string}', { timeout: -1 }, async ( phrase ) => {
   /** Tap a link that doesn't navigate. Depends on the language of the text. */
-  // exiting the custom timeout happens in scope.tapElement() if needed
+  // `page` timeout will deal with custom timeout
   await scope.steps.tap_term( scope, phrase );
 });
 
@@ -1022,7 +1150,7 @@ When(/I download "([^"]+)"$/, { timeout: -1 }, async ( filename ) => {
   *    page load. Just stick to the name of the file.
   */
   // TODO:
-  // This should be using `scope.tapElement()`? When someone clicks on a link to
+  // This should be using `scope.tapElementAndStayOnPage()`? When someone clicks on a link to
   // download a document, it sends a request to the server, which could be reloading
   return wrapPromiseWithTimeout(
     scope.steps.download( scope, filename ),
@@ -1130,6 +1258,12 @@ Given(/the final Scenario status should be "(passed|failed)"/i, async ( expected
 
 After(async function(scenario) {
 
+  // Log errors
+  if ( scenario.result.message ) {
+    log.debug({ type: `error`, pre: scenario.result.message });
+    // log.debug({ type: `error`, pre: scenario.result.message, verbose: true });
+  }
+
   let changeable_test_status = scenario.result.status;
   // The accessibility failures don't happen til the end, so the rest of the test can continue
   if ( scope.check_all_for_a11y && !scope.passed_all_for_a11y) {

package/lib/utils/log.js

@@ -40,14 +40,25 @@ log.error = function ({ type='', pre='', data='', post='' }) {
   if ( post ) { console.error( post, `\n` ); }
 };
 
-log.debug = function ({ type='', pre='', data='', post='' }) {
+log.debug = function ({ type='', pre='', data='', post='', verbose=false }) {
   /* If debugging is turned on, log a message that includes `ALKiln` and `debug` */
-  if ( session_vars.get_debug() ) {
+  if ( session_vars.get_debug() || verbose ) {
     let start = create_msg_start([ type, 'debug' ], pre );
+    let full = `\n${ start }`;
     // Log them each on a separate line
-    console.log( `ALKiln ${ type } debug: ${ pre }` );
-    if ( data ) { console.log( data ); }
-    if ( post ) { console.log( post ); }
+    console.log( `\n${ start }` );
+    if ( data ) {
+      full += `\n${ data }`;
+      console.log( data );
+    }
+    if ( post ) {
+      full += `\n${ post }`;
+      console.log( post );
+    }
+    // TODO: Make a verbose log instead of adding to the debug one and always add to it
+    if ( verbose ) {
+      log.add_to_debug_log( full );
+    }
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "5.7.0",
+  "version": "5.8.1-feat2columns1",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {