@suffolklitlab/alkiln 4.9.3 → 4.10.1

package/alkiln-2022-12-29 at 02h09m19s552ms UTC/tap element with an error-2022-12-29 at 02h12m18s853ms UTC/report.txt

@@ -0,0 +1,10 @@
+
+---------------
+Scenario: tap element with an error
+Tags: @interactive @i4 @tap-elements @tabs @error
+---------------
+Trying to load the interview
+
+ERROR: Couldn't find the tab with id "#Tests-not_there-tab" on the page, is there a typo?
+
+**-- Scenario Failed --**

package/alkiln-2022-12-29 at 02h09m19s552ms UTC/tap elements-2022-12-29 at 02h12m16s677ms UTC/report.txt

@@ -0,0 +1,6 @@
+
+---------------
+Scenario: tap elements
+Tags: @interactive @i3 @tap-elements @tabs
+---------------
+Trying to load the interview

package/docassemble/__init__.py

@@ -0,0 +1,5 @@
+try:
+    __import__('pkg_resources').declare_namespace(__name__)
+except ImportError:
+    __path__ = __import__('pkgutil').extend_path(__path__, __name__)
+

package/lib/scope.js

@@ -54,8 +54,34 @@ let is_secret_var = function(row) {
   return original.flags !== undefined && original.flags.secret_name !== undefined;
 }
 
+let fromBase64 = function(base64_str) {
+  /* Takes a base64 encoded string and returns it decoded.
+   * Note that this can take strings with invalid base 64 characters,
+   * but will change those characters to `/`s instead.
+   */
+  let buffer = Buffer.from( base64_str, 'base64' );
+  return buffer.toString( `utf-8` );
+}
+
+let toBase64 = function ( utf8_str, exclude_padding=true) {
+  /* Encoded a given string (@param utf8_str) in base64.
+   * @param exclude_padding {boolean} - if true, strips off `=` characters
+   *     that are added as padding while base64 encoding (docassemble doesn't
+   *     include those characters, and uses the UTF-7 base64 encoding
+   *     (RFC-2152)). For more details, see
+   *     https://github.com/nodejs/node/issues/6107#issuecomment-207177131
+   */
+  if ( typeof( utf8_str ) !== `string`  ) {  // Prevent an error
+    return `Will+Never+Match+Existing+DOM+Node==`;
+  }
+  let buffer = Buffer.from( utf8_str, 'utf-8' );
+  let base64str = buffer.toString( `base64` )
+  return exclude_padding ? base64str.replace(/=/g, '') : base64str;
+}
+
 let proxies_regex = /(\bx\.)|(\bx\[)|(\[[ijklmn]\])/g;
-let misc_artifacts_dir = `_alkiln_test-misc_artifacts`;
+let da_base64_regex = /^[A-Za-z0-9+/]+$/;
+let misc_artifacts_dir = `_alkiln-misc_artifacts`;
 
 module.exports = {
   trigger_not_needed_flag: `ALKiln: no trigger variable needed`,
@@ -620,7 +646,7 @@ module.exports = {
     * - Birthdate fields that will be showing up relatively soon
     * - Time fields?
     */
-    let base64_var_name = await scope.toBase64( scope, { utf8_str: var_name });
+    let base64_var_name = toBase64( var_name );
 
     // Will catch some radio and checkbox inputs too, which will then be rejected
     // Note: I think `showif`s with `code` don't use `data-saveas`
@@ -659,12 +685,14 @@ module.exports = {
     return to_manipulate;
   },  // Ends scope.setVar()
 
+  continue_button_selector: `fieldset.da-field-buttons button[type="submit"].btn-primary`,
+  signature_selector: `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(`fieldset.da-field-buttons button[type="submit"]`),  // other pages (this is the most consistent way)
-      scope.page.waitForSelector(`fieldset .dasigsave`),  // signature page
+      scope.page.waitForSelector(scope.continue_button_selector),  // other pages (this is the most consistent way)
+      scope.page.waitForSelector(scope.signature_selector),  // signature page
     ]);
     await elem.evaluate( el => { return el.className });
     // Waits for navigation or user error
@@ -675,15 +703,16 @@ module.exports = {
     /** Return true if a button that will allow continuing appears
     *    on this page. Otherwise return false. */
 
-    // Possible to find this on an event screen with `buttons:`, like an exit button
+    // Will only find this with "Continue buttons":
+    // * An actual continue button that doesn't set a variable
+    //   <button class="btn btn-da btn-primary" type="submit">Continue</button>
+    // * One that sets a variable:
+    //   <button type="submit" class="btn btn-da btn-primary" name="Zm9v" value="True">Continue</button>
+    // It will not find event screen `buttons:`, like an exit button or a restart button
     // <button type="submit" class="btn btn-da btn-danger" name="X211bHRpcGxlX2Nob2ljZQ" value="0">exit</button>
-    // An actual continue button that doesn't set a variable
-    // <button class="btn btn-da btn-primary" type="submit">Continue</button>
-    // One that sets a variable:
-    // <button type="submit" class="btn btn-da btn-primary" name="Zm9v" value="True">Continue</button>
     // `buttons:` can be used in question blocks as choices
-    let regular = await scope.page.$( `fieldset.da-field-buttons button[type="submit"]` );
-    let signature = await scope.page.$( `fieldset .dasigsave` );
+    let regular = await scope.page.$(scope.continue_button_selector);
+    let signature = await scope.page.$(scope.signature_selector);
 
     return regular !== null || signature !== null;
 
@@ -972,9 +1001,9 @@ module.exports = {
     if ( !encoded_trigger_var ) {
       // TODO: Add documentation and then link to it in this message.
       await scope.addToReport(scope, { type: `warning`, value: `You are missing an element containing the data for the page's trigger variable. Some fields, like loops with index variables, may not work correctly in these tests. See https://suffolklitlab.org/docassemble-AssemblyLine-documentation/docs/automated_integrated_testing/#a-missing-trigger-variable.` });
-      encoded_trigger_var = await scope.toBase64( scope, { utf8_str: `None` });
+      encoded_trigger_var = toBase64( `None` );
     }
-    let trigger = await scope.fromBase64( scope, { base64_str: encoded_trigger_var });
+    let trigger = fromBase64( encoded_trigger_var );
 
     
     // Some `show if` fields have `names` like '_field_n' instead of their var name. Ex: _field_1
@@ -1120,7 +1149,18 @@ module.exports = {
       // Inputs like textareas don't have values
       if ( values.length > 0 ) {
         for ( let value of values ){
-          possible_table_rows.push({ var: var_name, value, });
+          possible_table_rows.push({ var: var_name, value: value, });
+          // Ignore blanks, and values that certainly aren't base64 encoded like True and False
+          // Modified from https://stackoverflow.com/a/8571649/11416267
+          // DA doesn't use `==` to pad base 64
+          if (value !== 'None' && value !== 'True' && value !== 'False'
+              && value.match(da_base64_regex)) {
+            let value_decoded = fromBase64(value);
+            let values_decoded = scope.decodeFully( scope, {expr_str: value_decoded });
+            for (let possible_val of values_decoded) {
+              possible_table_rows.push({var: var_name, value: possible_val, });
+            }
+          }
         }
       } else {
         possible_table_rows.push({ var: var_name, value: '', });
@@ -1145,11 +1185,11 @@ module.exports = {
 
     let field_like_names = {};
     let field_like_names_encoded = $('input[name="_varnames"]')[0].attribs.value;
-    let field_like_names_str = await scope.fromBase64( scope, { base64_str: field_like_names_encoded });
+    let field_like_names_str = fromBase64( field_like_names_encoded );
     let field_like_names_json = JSON.parse( field_like_names_str );
     for ( let field_like_key in field_like_names_json ) {
-      let field_like_DOM_name = await scope.fromBase64( scope, { base64_str: field_like_key });
-      let field_like_var_name = await scope.fromBase64( scope, { base64_str: field_like_names_json[ field_like_key ]});
+      let field_like_DOM_name = fromBase64( field_like_key );
+      let field_like_var_name = fromBase64( field_like_names_json[ field_like_key ] );
       field_like_names[ field_like_DOM_name ] = field_like_var_name;
     }
 
@@ -1178,14 +1218,11 @@ module.exports = {
     *  @param encoded {str} - base64 encoded string of the node
     *  @param field_like_names {obj} - e.g. `{ _field_0: 'some_checkbox_var_name' }`
     *  @param nota {bool} - is the field a 'none of the above' field? */
-    let var_names = [];
-    let var_name = '';
-
     // E.g. continue buttons that don't set a variable
-    if ( encoded === undefined ) { return var_names; }
+    if ( encoded === undefined ) { return []; }
 
     // Names can be encoded multiple times, so start peeling the layers
-    let layer_1_decoded = await scope.fromBase64( scope, { base64_str: encoded });
+    let layer_1_decoded = fromBase64( encoded );
     // If this is of the format `_field_n`, we need to get the actual matching var name.
     if ( field_like_names[ layer_1_decoded ] ) {
       layer_1_decoded = field_like_names[ layer_1_decoded ];
@@ -1200,60 +1237,66 @@ module.exports = {
       // TODO: Should we move this back into `getAllFields()`?
     }
 
-    // A lot of checkbox fields have a key hidden inside them. (not yesno type checkboxes)
-    let checkbox_match = layer_1_decoded.match( /^(.*)\[[BR]'(.*)'\]/ );
+    return scope.decodeFully(scope, { expr_str: layer_1_decoded, field_like_names, nota });
+  },  // Ends scope.getPossibleVarNames()
+
+  decodeFully: function ( scope, { expr_str, field_like_names = {}, nota} ) {
+    /*
+    * Given a DA variable or value name, make sure it's fully decoded from base64.
+    *  @param variable_str {str} - a python variable string, potentially partially base64 encoded
+    *    Some examples:
+    *    - my_variable
+    *    - checkboxes_choices[B'Y2hlY2tib3hfb3RoZXJfb3B0XzI']
+    *    - foo[bar][B'Y2hlY2tib3hfb3RoZXJfb3B0XzI']
+    *  @param field_like_names {obj} - e.g. `{ _field_0: 'some_checkbox_var_name' }`
+    *  @param nota {bool} - is the field a 'none of the above' field?
+    */
+    // Some fields have a key hidden inside them.
+    // This gets the variable name before the final brackets, and the likely
+    // still base64 encoded string inside the brackets
+    let before_and_in_brackets = expr_str.match( /^(.*)\[[BR]'(.*)'\]/ );
 
     // Of the format `foo[B'encoded']` or `foo[R'encoded']`
+    // The B means internal to docassemble, the encoded portion is a string,
+    // and the R means that the python `repr` function was called with a
+    // non-string object
     // See https://github.com/jhpyle/docassemble/blob/595ad0a08572c0188f9ab49b1a6af99a3621cd42/docassemble_base/docassemble/base/standardformatter.py#L2108
 
-    // What about something like foo[R'encoded1'][B'encoded2']? Is that a
-    // thing? Can they be index numbers? Or just `foo['encoded1']`? What
-    // would their format be? The above? `foo[R'actual_choice'][B'encoded']`?
-    // `foo['something'][B'encoded']`?
-
     // =====================
     // Ex: checkboxes_choices[B'Y2hlY2tib3hfb3RoZXJfb3B0XzI']
     // Ex: checkboxes_choices[R'Y2hlY2tib3hfb3RoZXJfb3B0XzI']
-    if ( checkbox_match ) {
-
-      let key_or_name = checkbox_match[1];
+    let possible = [];
+    if ( before_and_in_brackets ) {
+      let key_or_name = before_and_in_brackets[1];
       // If this is of the format `_field_n`, we need to get the actual matching var name.
-      if ( field_like_names[ key_or_name ] ) {
-        var_name = field_like_names[ key_or_name ];
-      } else {
-        var_name = key_or_name;
-      }
+      let var_name = field_like_names [ key_or_name ] || key_or_name;
 
-      // Our own marker for a 'none of the above' checkbox choice
-      if ( nota ) { var_names.push( `${ var_name }['None']` ); }
-      else {
-        // Get the choice name. E.g. option_1, option_2
-        let box_layer_1_decoded = await scope.fromBase64( scope, { base64_str: checkbox_match[2] });
-        var_names.push( `${ var_name }['${ box_layer_1_decoded }']` );
+      let dictionary_key = before_and_in_brackets[2];
 
-        try {
-          // The part inside `[B'encoded']` could need one more decoding (or more?)
-          // It may have invalid chars if it's not a one-word var name, though, like '_'
-          let box_layer_2_decoded = await scope.fromBase64( scope, { base64_str: box_layer_1_decoded });
-          var_names.push(`${ var_name }['${ box_layer_2_decoded }']`);
-        } catch ( err ) {}  // It wasn't double encoded. Do nothing.
+      // Our own marker for a 'none of the above' checkbox choice
+      if ( nota ) { 
+        possible.push( `${ var_name }['None']` ); 
+      } else {
+        if (dictionary_key.match(da_base64_regex)) {
+          // Get the choice name. E.g. option_1, option_2
+          let dictionary_key_decoded = fromBase64( dictionary_key );
+          possible.push( `${ var_name }['${ dictionary_key_decoded }']` );
+          if (dictionary_key_decoded.match(da_base64_regex)) {
+            try {
+              // The part inside `[B'encoded']` could need one more decoding.
+              possible.push(`${ var_name }['${ fromBase64( dictionary_key_decoded ) }']`);
+            } catch ( err ) {}  // It wasn't double encoded. Do nothing.
+          }
+        }
       }
 
     // =====================
-    // Otherwise, just the var name (non checkboxes or yesno checkbox type things)
+    // If bracket regex didn't match, just use var name
     } else {
-      var_name = layer_1_decoded;
-      var_names.push(`${ layer_1_decoded }`);
-      // // Values are sometimes encoded multiple times (check this happens with a plain var name)
-      // let layer_2_decoded = await scope.fromBase64( layer_1_decoded );
-      // names.var_names.push( layer_2_decoded );
+      possible.push(`${ expr_str }`);
     }
-
-    // Detecting valid variable names/characters
-    // https://stackoverflow.com/a/23377268
-
-    return var_names;
-  },  // Ends scope.getPossibleVarNames()
+    return possible;
+  },
 
   getOptionValues: async function ( scope, { $select }) {
     /* Returns all the option node values of the select node. */
@@ -1261,35 +1304,11 @@ module.exports = {
     let option_nodes = $select.find( `option` );
     for ( let opt of option_nodes ) {
       options.push( opt.attribs.value );
-      // Dropdown options created with objects will be encoded
-      let decoded = await scope.fromBase64( scope, { base64_str: opt.attribs.value });
-      options.push( decoded );
+      // Dropdowns created w/ objects are base64 encoded; but it's handled in getPossibleTableRowMatches
     }
-    // TODO: These may be encoded? Just 'decode' and append those vals too.
-    // TODO: Keep those decoded values somewhere for setting the right
-    // option in the DOM. Not sure how that can be put together sensically.
     return options;
   },  // Ends scope.getOptionValues()
 
-  fromBase64: async function ( scope, { base64_str }) {
-    let buffer = Buffer.from( base64_str, 'base64' );
-    return buffer.toString( `utf-8` );
-  },
-
-  toBase64: async function ( scope, { utf8_str }, exclude_padding=true) {
-    if ( typeof( utf8_str ) !== `string`  ) {  // Prevent an error
-      return `Will+Never+Match+Existing+DOM+Node==`;
-    }
-    // Sometimes, converting to base64 results in padding characters ('=')
-    // being added to the end. Docassemble does not use these padding
-    // characters everywhere, so we allow for stripping them using 
-    // the exclude_padding argument. For more details, see
-    // https://github.com/nodejs/node/issues/6107#issuecomment-207177131
-    let buffer = Buffer.from( utf8_str, 'utf-8' );
-    let base64str = buffer.toString( `base64` )
-    return exclude_padding ? base64str.replace(/=/g, '') : base64str;
-  },
-
 
   // TODO: Maybe add `from_story_table` to the var data table (array...)
   getMatchingRows: async function ( scope, { field, var_data }) {
@@ -1481,7 +1500,12 @@ module.exports = {
       await scope.addToReport(scope, { type: `warning`, value: multiple_matches_msg });
     }
 
-    if ( session_vars.get_debug() ) { console.log( `final_matching_rows:\n`, JSON.stringify( final_matching_rows )); }
+    if ( session_vars.get_debug() ) { 
+      console.log( `final_matching_rows:\n`, JSON.stringify( final_matching_rows )); 
+      if ( final_matching_rows.length == 0) {
+        console.log(` field:\n`, JSON.stringify( field ) );
+      }
+    }
     return final_matching_rows;
   },  // Ends scope.getMatchingRows()
 
@@ -1685,8 +1709,6 @@ module.exports = {
     },
     select: async function ( scope, { handle, answer }) {
       // Note: I don't remember what's really going on in here.
-      // I will note that values of `select` elements are strings,
-      // not variables, so we don't need to check for variable names.
 
       // A dropdown's option value can be one of two things
       // Try to find the element using the first value
@@ -1707,7 +1729,7 @@ module.exports = {
       // If that literal value isn't on the page, it should be a base64 encoded value
       // TODO: Can these be double encoded? Can they be encoded like objects?
       } else {
-        let base64_name = await scope.toBase64( scope, { utf8_str: answer });
+        let base64_name = toBase64( answer );
         await handle.select( base64_name );
       }
       
@@ -1783,35 +1805,53 @@ module.exports = {
     /* Try to upload one or more files to a file-type input field.
     *    Does not submit, so no danger of timeout with server reload.
     */
-    
-    // Tests could be in one of two places. Figure out which directory they're in
-    // Makes an absolute path from the directory in which `npm run` was used plus our internal folders
-    let dir_source = `${ process.cwd() }/docassemble/${ session_vars.get_repo_url().match(/docassemble-(.*)/)[1] }/data/sources`;
-    let dir_features = `${ process.cwd() }/tests/features`;
-    let dir = null;
-
-    // Make sure one of the valid directories exist. This only allows
-    // one directory to be used per Step or table row. We don't anticipate
-    // future people having a `tests/features` folder, let alone both.
+
+    // Tests should be one place: docassemble/*/data/sources, where * is the only folder in `docassemble`.
+    // Makes an absolute path from the folder in which `npm run` was used plus our internal folders
+    let docassemble_pkg_path = `${ process.cwd() }/docassemble`;
+    let subpackage_name = session_vars.get_package_name().substring(12);
+    let pkg_paths = [];
     try {
-      // Try the most common directory first
-      fs.accessSync( dir_source );
-      dir = dir_source;
-      // If they have both directories, let them know which directory will be used.
-      try {
-        fs.accessSync( dir_features );
-        await scope.addToReport( scope, { type: `warning`, value: `You have both a docassemble package 'sources' folder and a 'test/features' folder. These tests will use the package's 'sources' folder.` });
-      } catch ( error_features ) { `all's well, do nothing`; }
+      fs.accessSync(docassemble_pkg_path);
+      // https://stackoverflow.com/a/24594123/11416267
+      let dirs = fs.readdirSync(docassemble_pkg_path, {withFileTypes: true}).filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
+      if (dirs.length < 1) {
+        let msg = `You can store files to upload in 'docassemble/${ subpackage_name }/data/source'. These tests could not find a folder like that starting at ${ process.cwd() }.`;
+        await scope.addToReport( scope, { type: `warning`, value: msg});
+        throw Error(msg);  // Most people will want to know the sources folder path;
+      }
+      for (let dir of dirs) {
+        pkg_paths.push(`${docassemble_pkg_path}/${dir}`);
+      }
+    } catch ( error_da ) {
+      let msg = `You can store files to upload in 'docassemble/${ subpackage_name }/data/source'. ` +
+          `These tests could not find a folder like that. The current directory is ` +
+          ` ${ process.cwd() }; is that in the top level folder of your docassemble package? (${ session_vars.get_package_name() })?`;
+      await scope.addToReport( scope, { type: `warning`, value: msg});
+      throw error_da;  // Most people will want to know the sources folder path;
+    }
 
-    } catch ( error_source ) {
+    let chosen_dir = null;
+    let err_paths = [];
+    for (let pkg_path of pkg_paths) {
+      let dir = `${ pkg_path }/data/sources`;
       try {
-        fs.accessSync( dir_features );
-        dir = dir_features;
-      } catch ( error_features ) {
-        await scope.addToReport( scope, { type: `warning`, value: `There are two places where you can store files to upload: "${ dir_source }" and "${ dir_features }". These tests could not find either of those.` });
-        throw error_source;  // Most people will want to know the sources folder path;
+        fs.accessSync(dir);
+        chosen_dir = dir;
+        break;
+      } catch ( error_full ) {
+        err_paths.push(`'${dir}'`);
       }
     }
+    if (chosen_dir === null) {
+      let msg = `You can store files to upload in ${err_paths.join(", or ")}. These tests could not find any of those folders.`;
+      await scope.addToReport( scope, { type: `warning`, value: msg });
+      throw Error(msg);  // Most people will want to know the sources folder path;
+    }
+
+    if (pkg_paths.length > 1 && pkg_paths.length - err_paths.length > 1) {
+      await scope.addToReport( scope, { type: `warning`, value: `You have multiple folders in the 'docassemble' folder (${ pkg_paths }). These tests will use the first folder with a "data/sources" subfolder (${chosen_dir}).` });
+    }
 
     // Allow a typo where someone forgot to include a space after a comma
     let file_names = answer.split(`,`);
@@ -1823,15 +1863,14 @@ module.exports = {
       // If the developer correctly used a ", ", there will be a space at the
       // start of the string. Remove it. If they forgot the space, that's fine too.
       name = name.replace(/^\s/, '');
-      let file_path = path.join( dir, name );
+      let file_path = path.join( chosen_dir, name );
 
       try {
         fs.accessSync( file_path );
         paths.push( file_path );
-
       } catch ( err ) {
         // TODO: Should this throw an error?
-        await scope.addToReport( scope, { type: `warning`, value: `Could not find "${ name }" in "${ dir }"` });
+        await scope.addToReport( scope, { type: `warning`, value: `Could not find "${ name }" in "${ chosen_dir }"` });
       }
     }
 
@@ -2127,13 +2166,18 @@ module.exports = {
         enhanced_var_data.push( special_row );
 
       // Neutralize a `.there_is_another` row in a story table
-      } else if ( from_story_table && var_datum.var.match( /\.there_is_another$/ ) ) {
+      } else if ( from_story_table && var_datum.var.match( /\.there_is_another$/ ) && var_datum.value !== `False`) {
         var_datum.invalid = true;
         // Removing the row will just cause a different error that will take longer to fail and
         // probably add a confusing message to the report, so mutating seems, sadly, more useful.
         var_datum.value = `False`;  // The original value is still preserved
         // Warn the developer not to use `.there_is_another`.
-        await scope.addToReport( scope, { type: `warning`, value: `The attribute \`.there_is_another\` is invalid in story table tests. Replace it with \`.target_number\` in your \`var\` and \`trigger\` columns. Set the \`value\` to the number of items in that list. This test will now set this row's \`value\` to \`False\`. See https://suffolklitlab.github.io/docassemble-AssemblyLine-documentation/docs/automated_integrated_testing#there_is_another. The row data is\n${ JSON.stringify( var_datum.original )}` });
+        await scope.addToReport( scope, { type: `warning`, 
+            value: 'The attribute `.there_is_another` is invalid in story table tests. Replace it with '
+              + '`.target_number` in your `var` and `trigger` columns. Set the `value` to the number of items in '
+              + `that list. This test will now set this row's \`value\` to \`False\`. See `
+              + `https://suffolklitlab.github.io/docassemble-AssemblyLine-documentation/docs/automated_integrated_testing#there_is_another. `
+              + `The row data is\n${ JSON.stringify( var_datum.original )}` });
       }
     }
 
@@ -2821,4 +2865,24 @@ module.exports = {
 
     return all_are_included;
   },  // Ends scope.reportIncludesAllExpected()
+
+  reportDoesNotInclude: async function ( scope, { not_expected=[] }) {
+    /* Tests the behavior of this testing framework.
+    * Test whether the expected values are not included in the test report.
+    * 
+    * @param not_expected {array} Arr of strs that should not appear in the report.
+    */
+    let current_report_obj = scope.report.get( scope.scenario_id );
+    let scenario = [ scope.scenario_id, current_report_obj ];  // Mimic how loop works with `Map`
+    let report = await scope.getPrintableScenario( scope, { scenario });
+    let none_included = true;
+    for ( let one_expectation of not_expected ) {
+      if ( report.includes( one_expectation )) {
+        none_included = false;
+        expect( report ).not.to.contain( one_expectation );
+      }
+    }
+
+    return none_included;
+  },
 };

package/lib/steps.js

@@ -115,6 +115,7 @@ Before(async (scenario) => {
   scope.scenario_id = uuidv4();
   scope.expected_status = null;
   scope.expected_in_report = null;
+  scope.expected_not_in_report = null;
   scope.server_reload_promise = null;
 
   await scope.addReportHeading(scope, {scenario});
@@ -1068,6 +1069,19 @@ Given(/the Scenario report should include/i, async ( report_text ) => {
 
 });
 
+Given(/the Scenario report should not include/i, async ( report_text ) => {
+  /* WARNING: If a Step will fail, this Step must come first.
+  * 
+  * Prepare to test that the Scenario report does not include `report_text`.
+  * The actual test has to be done at the end of the Scenario as some text
+  * may be added to the report there. */
+  if ( !scope.expected_not_in_report ) {
+    scope.expected_not_in_report = [];
+  }
+  scope.expected_not_in_report.push( report_text );
+
+});
+
 Given(/the final Scenario status should be "(passed|failed)"/i, async ( expected_status ) => {
   /* WARNING: If a Step will fail, this Step must come first.
   * 
@@ -1156,6 +1170,20 @@ After(async function(scenario) {
     else { scenario.result.status = `FAILED`; }
   }
 
+  if (scope.expected_not_in_report && scope.expected_not_in_report.length > 0) {
+    let not_expected = scope.expected_not_in_report;
+    // Reset report values no matter what so they don't mess up future scenarios
+    scope.expected_not_in_report = null;
+    let all_were_not_there = await scope.reportDoesNotInclude( scope, { not_expected });
+
+    if ( all_were_not_there ) {
+      scenario.result.status = `PASSED`;
+    } else { 
+      scenario.result.status = `FAILED`;
+    }
+
+  }
+
   // If there is a page open, then sign out and close it
   if ( scope.page ) {
     // Catch a possible reload error.

package/lib/utils/files.js

@@ -11,14 +11,14 @@ files.readable_date = function() {
   */
   let date = new Date();  // now
   let day = ("0" + date.getUTCDate()).slice(-2);
-  let month = ("0" + date.getUTCMonth() + 1).slice(-2);
+  let month = ("0" + (date.getUTCMonth() + 1)).slice(-2);
   let year = date.getUTCFullYear();
   let hours = ("0" + date.getUTCHours()).slice(-2);
   let mins = ("0" + date.getUTCMinutes()).slice(-2);
   let secs = ("0" + date.getUTCSeconds()).slice(-2);
   let msecs = ("00" + date.getUTCMilliseconds()).slice(-3);
 
-  let fancy_str = `${ year }-${ month }-${ day } at ${ hours }hr ${ mins }min ${ secs }sec ${ msecs }ms UTC`;
+  let fancy_str = `${ year }-${ month }-${ day } at ${ hours }h${ mins }m${ secs }s${ msecs }ms UTC`;
   return fancy_str;
 };  // Ends files.readable_date()
 
@@ -31,7 +31,7 @@ files.make_artifacts_folder = function (folder_name) {
   if (folder_name) {
     folder_name = safe_filename( folder_name );
   } else {
-    folder_name = `alkiln_tests_output-${ files.readable_date() }`
+    folder_name = `alkiln-${ files.readable_date() }`
   }
 
   fs.mkdirSync( folder_name );

package/lib/utils/session_vars.js

@@ -67,13 +67,15 @@ session_vars.get_branch_name = function () {
   return branch_name;
 };
 
-session_vars.get_project_base_name = function () {
+session_vars.get_package_name = function () {
   /* Make an un-incremented project name based on the repo name and branch name. */
   let repo_url_without_trailing_slash = session_vars.get_repo_url().replace(/\/$/, '');
   let repo_name_parts = repo_url_without_trailing_slash.split('/');
-  let package_name = repo_name_parts[ repo_name_parts.length - 1 ];
+  return repo_name_parts[ repo_name_parts.length - 1 ];
+};
 
-  let name = `testing${ package_name }${ session_vars.get_branch_name() }`;
+session_vars.get_project_base_name = function () {
+  let name = `testing${ session_vars.get_package_name() }${ session_vars.get_branch_name() }`;
   let sanitized_name = name.replace( /[^A-Za-z0-9]/g, '' );
   return sanitized_name;
 };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "4.9.3",
+  "version": "4.10.1",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
     "test": "npm run unit && npm run langs_setup && npm run cucumber -- $@",
     "cucumber_base": "run_cucumber(){ ./node_modules/.bin/cucumber-js \"$@\"; status=$?; ./lib/utils/clean_reports.js; return $status; }; run_cucumber",
-    "cucumber": "run_base(){ npm run cucumber_base -- \"$@\" tests/features/*.feature --retry 1; }; run_base",
+    "cucumber": "run_base(){ npm run cucumber_base -- \"$@\" docassemble/*/data/sources/*.feature --retry 1; }; run_base",
     "cucumber_external": "run_cucumber(){ tmp_path=`pwd`; ( new_path=\"$1\"; shift; cd \"$new_path\"; npm run --prefix \"${tmp_path}\" cucumber_base -- \"$@\" \"$new_path\"/docassemble/*/data/sources/*.feature;) }; run_cucumber",
-    "langs": "npm run langs_setup && ./node_modules/.bin/cucumber-js --require ./lib/index.js tests/features/*_lang*.feature",
-    "langs_setup": "./lib/utils/langs.js 'tests/features/*.feature'",
+    "langs": "npm run langs_setup && ./node_modules/.bin/cucumber-js --require ./lib/index.js docassemble/*/data/sources/*_lang*.feature",
+    "langs_setup": "./lib/utils/langs.js 'docassemble/*/data/sources/*.feature'",
     "langs_local": "npm run langs_setup && npm run local",
     "local": "npm run setup && npm run cucumber; npm run takedown",
     "setup": "./lib/docassemble/setup.js",
@@ -42,6 +42,7 @@
     "chai": "4.2.0",
     "cheerio": "1.0.0-rc.10",
     "dotenv": "8.2.0",
+    "deep-equal-in-any-order": "^2.0.0",
     "mocha": "9.2.0",
     "puppeteer": "13.1.3",
     "qs": "6.10.2",