@suffolklitlab/alkiln 4.6.2 → 4.7.0

package/CHANGELOG.md

@@ -40,6 +40,13 @@ Format:
 -->
 <!-- ## [Unreleased] -->
 
+## [4.7.0] - 2022-07-27
+### Added
+- Generate random input to fill out a simple form automatically
+
+### Changed
+- Add page id to the "Missing Variable or variables on page" error report
+
 ## [4.6.2] - 2022-06-28
 ### Changed
 - Put cucumber tests' artifacts in one folder. See https://github.com/SuffolkLITLab/ALKiln/issues/552.

package/lib/scope.js

@@ -4,6 +4,8 @@ const path = require('path');
 const fs = require('fs');
 const { AxePuppeteer } = require('@axe-core/puppeteer');
 const safe_filename = require("sanitize-filename");
+// "en" is faster to import: https://github.com/faker-js/faker/issues/1114#issuecomment-1169532948
+const faker = require('@faker-js/faker/locale/en').faker;
 
 // Ours
 const session_vars = require('./utils/session_vars');
@@ -488,7 +490,7 @@ module.exports = {
 
     // Do your own waiting if you need to in the step
     return to_manipulate;
-  },  // Ends setVar()
+  },  // Ends scope.setVar()
 
   continue: async function ( scope ) {
     /* Presses whatever button it finds that might lead to the next page. */
@@ -500,7 +502,25 @@ module.exports = {
     await elem.evaluate( el => { return el.className });
     // Waits for navigation or user error
     await scope.tapElement( scope, elem );
-  },
+  },  // Ends scope.continue()
+
+  continue_exists: async function ( scope ) {
+    /** 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
+    // <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` );
+
+    return regular !== null || signature !== null;
+
+  },  // Ends scope.continue_exists()
 
   tapTab: async function ( scope, tab_id ) {
     let elem = await scope.page.$(`#${tab_id}`); 
@@ -967,6 +987,9 @@ module.exports = {
       // names.var_names.push( layer_2_decoded );
     }
 
+    // Detecting valid variable names/characters
+    // https://stackoverflow.com/a/23377268
+
     return var_names;
   },  // Ends scope.getPossibleVarNames()
 
@@ -1233,13 +1256,7 @@ module.exports = {
       await scope.page.waitForSelector('#dasigcanvas');
     }
 
-    let handle = await scope.page.evaluateHandle(( selector, field ) => {
-      let elem = document.querySelector( selector );
-      // `elem` has never been null
-      if ( elem.nextSibling && elem.nextSibling.tag === `label` ) {
-        return elem.nextSibling;
-      } else { return elem; }
-    }, field.selector, field );
+    let handle = await scope.get_handle_from_field( scope, { field: field });
 
     let disabled = await handle.evaluate(( elem )=> {
       // da's header covers the top of the section containing the fields which means
@@ -1260,15 +1277,39 @@ module.exports = {
       await scope.page.waitForTimeout( 400 );
     }
 
-    let { tag, type } = field;
     // We use the last match. We wrote a warning for the user if there were
     // multiple matches in the story that the last value will be used. In future,
     // Steps will be able to set this data gradually and we don't want the developer
     // to get confused thinking that an earlier Step was used instead of a later one.
     let row = matching_input_rows[ matching_input_rows.length - 1 ];
-    let set_to = row.value;
+    let answer = row.value;
+
+    await scope.funnel_the_answer( scope, { handle, answer, field });
+
+    return row;
+  },  // Ends scope.setVariable()
+
+  get_handle_from_field: async function ( scope, { field }) {
+    /** Get the element's puppeteer handle using the field's 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
+      // interact with that label instead.
+      // `elem` has never been null from what we've seen
+      if ( elem.nextSibling && elem.nextSibling.tag === `label` ) {
+        return elem.nextSibling;
+      } else { return elem; }
+    // Pass in the selector as an argument
+    }, field.selector );
+
+    return handle;
+  },  // Ends scope.get_handle_from_field()
+
+  get_custom_datatype: async function( scope, { handle }) {
+    /** If this is part of a custom datatype, returns an element,
+    *    otherwise returns null. */
 
-    // Detect a custom type and get the element of that custom type if it exists
     let custom_datatype = await handle.evaluate(( elem )=> {
       // If the element is in a form group**, then extract the form group's
       // datatype value.
@@ -1287,28 +1328,52 @@ module.exports = {
       return custom_datatype;
     });
 
-    // Set field
-    if ( scope.setCustomDatatype[ custom_datatype ] === undefined ) {
-      // If no custom datatype, set a regular field
-      await scope.setField[ tag ]( scope, { handle, set_to });
-    } else {
+    return custom_datatype;
+  },  // Ends scope.is_custom_datatype()
+  
+  funnel_the_answer: async function( scope, { handle, field, answer }) {
+    /** Use the tag or custom datatype to funnel the answer to the right
+    *    field. Pages without a handle should pass in `null` for the
+    *    handle.
+    */
+
+    let custom_datatype = null;
+    // Pages with elements like `canvas` for signatures won't have a handle
+    // to pass in. They should pass in `null` for the handle and shouldn't
+    // need a handle in order to function.
+    if ( handle !== null ) {
+      // Get the element of that custom type if it exists
+      custom_datatype = await scope.get_custom_datatype( scope, { handle });  
+    }
+
+    // If there is a custom datatype function available, use it to set the field
+    if ( scope.setCustomDatatype[ custom_datatype ] !== undefined ) {
       // Set da package custom fields. TODO: find `custom_handle` in the setter?
       let custom_handle = await handle.evaluateHandle(( elem )=> { return elem.closest( `.da-form-group` ) });
-      await scope.setCustomDatatype[ custom_datatype ]( scope, { handle: custom_handle, set_to });
+      await scope.setCustomDatatype[ custom_datatype ]( scope, { handle: custom_handle, answer });
+    } else {
+      // If no custom datatype, set a regular field
+      await scope.enter_answer[ field.tag ]( scope, { handle, answer });
     }
 
-    return row;
-  },  // Ends scope.setVariable()
+  },  // Ends scope.funnel_the_answer()
 
   // Handle setting values for da custom datatypes. E.g. `da-field-container-datatype-BirthDate`
   // TODO: Make this more easily extensible.
-  // TODO: Just put this in `scope.setField`? Find the custom handle in the setter itself.
+  // TODO: Just put this in `scope.enter_answer`? Find the custom handle in the setter itself.
   setCustomDatatype: {
-    "BirthDate": async function ( scope, { handle, set_to }) {
+    al_date: async function ( scope, { handle, answer, is_past }) {
       /* Given a date of the format 'mm/dd/yyyy' and the handle of the
-      * custom field container, sets the ALToolbox custom birthdate
+      * custom field container, sets an AssemblyLine three-part date's
       * field values. */
-      let date_parts = set_to.split(`/`);
+
+      // If it doesn't have the right format
+      if ( answer === null || !answer.includes(`/`) ) {
+        // Do nothing
+        return;
+      }
+
+      let date_parts = answer.split(`/`);
       let fields = await handle.$$(`select, input:not([type="hidden"])`);
       for ( let field_i = 0; field_i < fields.length; field_i++ ) {
         let field = fields[ field_i ];
@@ -1321,55 +1386,76 @@ module.exports = {
           // Set the month
           await field.select( date_parts[ 0 ] );
         } else {
-          // Set the day and year
+          // Set the day or year
           await scope.setText( scope, {
             handle: field,
-            set_to: date_parts[ field_i ]
+            answer: date_parts[ field_i ]
           });
         }
 
       }  // For each field
 
       await scope.afterStep( scope );
-    },  // Ends BirthDate()
+    },  // Ends scope.setCustomDatatype.al_date()
 
+    BirthDate: async function ( scope, { handle, answer }) {
+      /** Given a date of the format 'mm/dd/yyyy' and the handle of the
+      * custom field container, sets the ALToolbox custom birthdate
+      * field values. */
+
+      await scope.setCustomDatatype.al_date( scope, { handle, answer })
+    },  // Ends scope.setCustomDatatype.BirthDate()
+
+    ThreePartsDate: async function ( scope, { handle, answer }) {
+      /** Given a date of the format 'mm/dd/yyyy' and the handle of the
+      * custom field container, sets the ALToolbox custom ThreePartsDate
+      * field values. */
+      await scope.setCustomDatatype.al_date( scope, { handle, answer })
+    },  // Ends scope.setCustomDatatype.ThreePartsDate()
 
   },  // ends setCustomDatatype {}
 
-  setField: {
-    button: async function ( scope, { handle, set_to }) { await scope.tapElement( scope, handle ); },
-    textarea: async function ( scope, { handle, set_to }) {
-      await scope.setText( scope, { handle, set_to });
+  enter_answer: {
+    button: async function ( scope, { handle, answer }) { await scope.tapElement( scope, handle ); },
+    textarea: async function ( scope, { handle, answer }) {
+      await scope.setText( scope, { handle, answer });
       await scope.afterStep(scope);  // No showifs for this one?
     },
-    select: async function ( scope, { handle, set_to }) {
+    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
 
-      // TODO: Can we somehow pass in a `set_to` that is encoded correctly since
+      // TODO: Can we somehow pass in a `answer` that is encoded correctly since
       // we're getting the fields from the DOM to begin with? We'll probably
       // need another prop because we need the `option` human value to
       // match the story table
 
       // TODO: Change this to search in the actual handle instead of just $
-      let option = await scope.page.$(`option[value="${ set_to }"]`);
+      // There could be multiple fields on the page with the same option
+      // values.
+      // let option = await handle.$(`option[value="${ answer }"]`);
+      let option = await scope.page.$(`option[value="${ answer }"]`);
       if ( option ) {
-        await handle.select( set_to );  // And use that value to set it
+        await handle.select( answer );  // And use that value to set it
 
       // If that literal value isn't on the page, it should be a base64 encoded value
-      // TODO: Can these be double encoded?
+      // TODO: Can these be double encoded? Can they be encoded like objects?
       } else {
-        let base64_name = await scope.toBase64( scope, { utf8_str: set_to });
+        let base64_name = await scope.toBase64( scope, { utf8_str: answer });
         await handle.select( base64_name );
       }
       
       await scope.afterStep(scope, { waitForShowIf: true });
     },
-    canvas: async function ( scope, { handle, set_to }) {
+    canvas: async function ( scope, { handle, answer }) {
       await scope.sign( scope );
       await scope.afterStep( scope );
     },
-    input: async function ( scope, { handle, set_to }) {
+    input: async function ( scope, { handle, answer }) {
       /* Set value of some `input` element to the given value. */
 
       let type = await handle.evaluate( elem => { return elem.getAttribute('type'); });
@@ -1378,50 +1464,60 @@ module.exports = {
         let [label] = await handle.$x(`following-sibling::label`);
         
         if ( session_vars.get_debug() ) {
-          if ( set_to.toLowerCase() === 'false' ) { await label.evaluate( elem => { elem.style.background = 'tomato'; }); }
+          if ( answer.toLowerCase() === 'false' ) { await label.evaluate( elem => { elem.style.background = 'tomato'; }); }
           else { await label.evaluate( elem => { elem.style.background = 'teal'; }); }
           let name = await label.evaluate( elem => { return elem.getAttribute('for'); });
         }
 
         if ( type === `radio` ) { await label.evaluate( elem => { return elem.click(); }); }
-        else { await scope.setCheckbox( scope, { label, set_to }); }
+        else { await scope.setCheckbox( scope, { label, answer }); }
 
         await scope.afterStep(scope, { waitForShowIf: true });
         
       } else if ( type === `file` ) {
-        await scope.uploadFiles( scope, { handle, set_to });
+        await scope.uploadFiles( scope, { handle, answer });
         await scope.afterStep(scope, { waitForShowIf: true });
 
       } else if (type == `date`) {
-        let set_to_date = set_to;
+        let answer_date = answer;
         // If the date is specified in the format "today" or "today + 2" or "today-1"
         // it will need some pre-processing. 
-        if (set_to.indexOf(`today`) !== -1) {
+        if (answer.indexOf(`today`) !== -1) {
           // Find out how many days to add/subtract
-          let date_delta = set_to.replace(/\s/g, '');
+          let date_delta = answer.replace(/\s/g, '');
           date_delta = date_delta.match(/today([+-]\d+)?/)[1];
           date_delta = date_delta == undefined ? 0 : date_delta;
           date_delta = parseInt(date_delta);
           // Get today's date
-          set_to_date = new Date(); 
+          answer_date = new Date(); 
           // Add/subtract required number of days
-          set_to_date.setDate(set_to_date.getDate() + date_delta);
+          answer_date.setDate(answer_date.getDate() + date_delta);
           // Convert to the docassemble date field format: mm/dd/yyyy
           // Reference: https://gomakethings.com/setting-a-date-input-to-todays-date-with-vanilla-js/
-          set_to_date = ((set_to_date.getMonth() + 1).toString().padStart(2, 0) + '/' + 
-                         set_to_date.getDate().toString().padStart(2, 0) + '/' +
-                         set_to_date.getFullYear().toString());
+          answer_date = ((answer_date.getMonth() + 1).toString().padStart(2, 0) + '/' + 
+                         answer_date.getDate().toString().padStart(2, 0) + '/' +
+                         answer_date.getFullYear().toString());
         }
-        await scope.setText( scope, { handle, set_to: set_to_date });
+        await scope.setText( scope, { handle, answer: answer_date });
         await scope.afterStep(scope, { waitForShowIf: true });
       } else {
-        await scope.setText( scope, { handle, set_to });
+        await scope.setText( scope, { handle, answer });
         await scope.afterStep(scope, { waitForShowIf: true });
       }
-    },  // Ends scope.setField.input()
-  },
+    },  // Ends scope.enter_answer.input()
+    hidden: async function ( scope, { handle, answer }) {
+      // Do nothing. The only way the code should get here is if
+      // this wasn't a custom datatype we can handle.
+      // If we were to write a message, I don't know what we can
+      // write - this may be a different custom datatype or this
+      // could be a special da field that we shouldn't worry the
+      // dev about at all.
+      return;
+    },
+
+  },  // ends scope.enter_answer
 
-  uploadFiles: async function ( scope, { handle, set_to }) {
+  uploadFiles: async function ( scope, { handle, answer }) {
     /* Try to upload one or more files to a file-type input field. */
     
     // Tests could be in one of two places. Figure out which directory they're in
@@ -1454,7 +1550,7 @@ module.exports = {
     }
 
     // Allow a typo where someone forgot to include a space after a comma
-    let file_names = set_to.split(`,`);
+    let file_names = answer.split(`,`);
 
     // If a file exist, add it to a list of files to be uploaded. If it doesn't, add a warning.
     let paths = [];
@@ -1476,8 +1572,8 @@ module.exports = {
     }
 
     if ( paths.length === 0 ) {
-      await scope.addToReport( scope, { type: `error`, value: `Could not find "${set_to}".` });
-      throw ReferenceError(`Could not find "${set_to}".`)
+      await scope.addToReport( scope, { type: `error`, value: `Could not find "${answer}".` });
+      throw ReferenceError(`Could not find "${answer}".`)
     } 
     // Prepare to wait for upload to complete
     let name = await handle.evaluate( elem => { return elem.getAttribute(`name`); });
@@ -1502,20 +1598,20 @@ module.exports = {
 
   },  // Ends scope.uploadFiles()
 
-  setCheckbox: async function ( scope, { label, set_to }) {
+  setCheckbox: async function ( scope, { label, answer }) {
     // Depending on the current value/status of a checkbox and the desired
     // value to set, either taps the checkbox or leaves it alone.
     let status = await label.evaluate( elem => { return elem.getAttribute('aria-checked'); });
-    if ( set_to.toLowerCase() !== status ) {
+    if ( answer.toLowerCase() !== status ) {
       await label.evaluate( elem => { return elem.click(); });
     }
   },  // Ends scope.setCheckbox()
 
-  setText: async function ( scope, { handle, set_to }) {
+  setText: async function ( scope, { handle, answer }) {
     // Set text in some kind of field (input text, input date, textarea, etc.)
     await handle.evaluate( el => { el.value = '' });
     await handle.focus();
-    await handle.type( set_to );
+    await handle.type( answer );
     setTimeout(async () => {
     }, 500)
   },
@@ -1562,7 +1658,7 @@ module.exports = {
   },  // Ends scope.examinePageID()
 
   // TODO: Rename var_data to input_data?
-  // Note: Totally different from `setField` (which is singular)
+  // Note: Totally different from `enter_answer` (which is singular)
   // TODO: If a step triggers this and is not able to set a value, should it error?
   // TODO: Rename to setFieldsOfOnePage? setPageFields?
   setFields: async function ( scope, {
@@ -1691,7 +1787,8 @@ module.exports = {
         }
       }
       if ( num_unused_rows > 0 ) {
-        let msg = `Missing variable or variables on page.`;
+        let { id } = await scope.examinePageID( scope, 'none to match' );
+        let msg = `Missing variable or variables on page "${id}"`;
         await scope.addToReport(scope, { type: `error`, value: msg });
         expect( num_unused_rows, msg ).to.equal( 0 );
       }
@@ -1971,7 +2068,7 @@ module.exports = {
       await scope.afterStep(scope);
     },  // Ends link_works()
 
-    set_regular_var: async ( scope, var_name, set_to ) => {
+    set_regular_var: async ( scope, var_name, answer ) => {
       /** Set a non-story table variable (with or without a choice associated with it) to a value. Set:
       *  - Buttons associated with variables
       *  - Dropdowns
@@ -1982,23 +2079,23 @@ module.exports = {
       */
       // Let kiln know not to test against trigger variable values, even for proxy vars
       let var_data = await scope.normalizeTable( scope, {
-        var_data: [{ var: var_name, value: set_to, trigger: scope.trigger_not_needed_flag }],
+        var_data: [{ var: var_name, value: answer, trigger: scope.trigger_not_needed_flag }],
       });
       // Don't continue if the variable doesn't cause navigation itself. Also,
       // if this variable cannot be set on this page, trigger an error
       await scope.setFields( scope, { var_data, ensure_navigation: false, ensure_all_vars_used: true });
     },  // Ends set_regular_var()
 
-    set_secret_var: async ( scope, var_name, set_to_env_name ) => {
+    set_secret_var: async ( scope, var_name, answer_env_name ) => {
       /** Sets a non-story table variable to a "secret" value (i.e. an env var) */
       // Prevent pictures of a screen with a secret.
       scope.disable_error_screenshot = true;
       let var_data = await scope.normalizeTable( scope, {
               var_data: [{
                 var: var_name,
-                value: set_to_env_name,
+                value: answer_env_name,
                 trigger: scope.trigger_not_needed_flag,
-                flags: {secret_name: set_to_env_name}
+                flags: {secret_name: answer_env_name}
               }],
       });
       // Don't continue if the variable doesn't cause navigation itself. Also,
@@ -2170,10 +2267,235 @@ module.exports = {
       });
 
       await scope.afterStep(scope, {waitForShowIf: false});
-    },  // Ends sign_in
+    },  // Ends scope.steps.sign_in()
+
+    set_random_page_vars: async ( scope ) => {
+      /** Answer inputs randomly. */
+
+      let html = await scope.page.content();
+      // These are the fields on the current page. Their handles should all exist.
+      let fields = await scope.getAllFields( scope, { html: html });
+      let buttons = [];
+
+      // For every field on the page
+      for ( let field of fields ) {
+
+        // fields[n].tag is HTML tag of node, as a string
+
+        // If the field is a button, save it in a list of buttons that we'll deal with later
+        if ( field.tag === `button` ) {
+          buttons.push( field );
+        } 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
+        }
+
+      }  // End for all page fields
+
+      return buttons;
+
+    },  // Ends scope.steps.set_random_page_vars()
 
   },  // ends scope.steps
 
+  set_random_input_for: {
+    a: async function (scope, { fields }) {
+      // We don't do anything with links for random input tests
+    }, 
+    buttons: async function (scope, { fields }) {
+      // Get a random button
+      let field = faker.helpers.arrayElement( fields );
+      let handle = await scope.get_handle_from_field( scope, { field: field });
+      // Send it to be tapped
+      await scope.funnel_the_answer( scope, { handle, field, answer: `doesn't matter` });
+    },
+    textarea: async function (scope, { field }) {
+      // Get random paragraph of text
+      let answer = faker.lorem.paragraph();
+      // Get the element's puppeteer handler
+      let handle = await scope.get_handle_from_field( scope, { field: field });
+      // Type the random text into the textarea
+      await scope.funnel_the_answer( scope, { handle, field, answer: answer });
+    },
+    select: async function (scope, { field }) {
+      // Get the values of all the options of the field
+      let handle = await scope.get_handle_from_field( scope, { field: field });
+      // Get the values of all the choices
+      let answer_choices = await handle.evaluate(function ( elem ) {
+        let values = Array.from(elem.querySelectorAll(`option`)).map(element=>element.value);
+        return values;
+      });
+
+      // Remove the "no selection" option from the list ('')
+      // TODO: blue sky - for optional fields allow no selection
+      if ( answer_choices[0] === `` ) {
+        answer_choices.shift();
+      }
+
+      // Select randomly between them
+      let answer = faker.helpers.arrayElement( answer_choices );
+
+      // Set that value
+      await scope.funnel_the_answer( scope, { handle, field, answer: answer });
+
+    },
+    canvas: async function (scope, { field }) {
+      // WARNING: Do not test this in headless mode.
+      // If we do this in headless mode, the test will fail. It signs, but
+      // can't continue. Not sure why.
+      await scope.funnel_the_answer( scope, { field, handle: null, answer: `doesn't matter` });
+    },
+    input: async function (scope, { field }) {
+      /** Handles various `type`s of input element fields, except:
+      * 
+      * Does not handle "file" type
+      * Does not handle custom data values yet, like BirthDate, because they have
+      *    `type="hidden"` which also matches other special da fields on the
+      *    page that we SHOULDN'T interact with.
+      * Does not handle range, which is not a `type`, but it is an input element
+      */
+
+      // Use the type instead of the tag to get get the answer for
+      // an input field
+      let type = field.type;
+      
+      // Custom datatype question: Do all custom datatypes hide their
+      // original field? Probably not...
+      // TODO: Move custom datatype checking to the caller of this
+      // function somehow - in future, not all custom datatypes will
+      // be inputs _and_ this won't handle, for example, a `select` field
+      // that is part of a custom datatype with a hidden field - this
+      // doesn't take care of that situation.
+
+      let handle = await scope.get_handle_from_field( scope, { field: field });
+
+      // If this is a custom datatype
+      let custom_datatype = await scope.get_custom_datatype( scope, { handle });
+      let is_custom_datatype = scope.get_random_input_for[ custom_datatype ] !== undefined;
+      if ( is_custom_datatype ) {
+
+        // And the custom datatype has a hidden field (which will be the original field)
+        let hidden_field = await scope.get_custom_datatype_hidden_field( scope, { handle });
+        if ( hidden_field !== null ) {
+          // only set the value once - just for the original field
+          if ( type === `hidden` ) {
+
+            // set the value
+            let answer = await scope.get_random_input_for[ custom_datatype ]( scope );
+            await scope.funnel_the_answer( scope, { handle, field, answer });
+
+          }
+          // Otherwise ignore the non-original field
+
+        // Untested: If no hidden field exists, just try to set the custom
+        // datatype field
+        } else {
+          // set the value
+          let answer = await scope.get_random_input_for[ custom_datatype ]( scope );
+          await scope.funnel_the_answer( scope, { handle, field, answer });
+        }
+
+      // If this is not a custom datatype
+      } else {
+
+        // `file` type inputs come next to an input with a type of ''.
+        // Maybe others do too.
+        if ( type !== `` && type !== `hidden` ) {
+          // Field types that we can't yet handle, but plan to in future
+          if ( type === `file` ) {
+            await scope.addToReport( scope, {
+              type: `warning`,
+              value: `Sorry, ALKiln's random-input cannot yet handle "${ type }" fields.`
+            });
+          } else {
+            let answer = await scope.get_random_input_for[ type ]( scope );
+            await scope.funnel_the_answer( scope, { handle, field, answer });
+          }  // ends if field type is one we cover
+        }  // ends if field type exists
+
+      }  // ends if is custom datatype
+
+    },  // ends scope.set_random_input_for.input
+  },  // ends scope.set_random_input_for
+
+  get_custom_datatype_hidden_field: async function (scope, { handle }) {
+    /** If there's a hidden field in a custom datatype, returns that
+    *    DOM node, otherwise returns null. */
+
+    let hidden_field = await handle.evaluate(( elem )=> {
+      // If the element is in a form group**, then extract the form group's
+      // datatype value.
+      // ** For now the only custom datatype we have is in a form group. In
+      // future we should look into what happens with a `fieldset` for
+      // `choices:`, etc.
+      let custom_datatype = null, matches = null;
+      let group = elem.closest( `.da-form-group` );
+      // Returns an element or null
+      let hidden_child = group.querySelector( `[type="hidden"]` );
+
+      return hidden_child;
+    });
+
+    return hidden_field;
+  },  // Ends scope.get_custom_datatype_hidden_field()
+
+  get_random_input_for: {
+    checkbox: async function ( scope ) {
+      return `${ Math.random() > .5 }`;
+    },
+    radio: async function ( scope ) {
+      return `${ Math.random() > .5 }`;
+    },
+    text: async function ( scope ) {
+      return faker.random.word();
+    },
+    number: async function ( scope ) {
+      let answer = faker.helpers.arrayElement( [`1`, `2`, `3`], 1 );
+      return answer;
+    },
+    date: async function ( scope ) {
+      let past = faker.date.past(25);
+      let future = faker.date.future(1);
+
+      let date = null;
+      if ( Math.random() > .5 ) {
+        date = past;
+      } else {
+        date = future;
+      }
+      // Ensure 2-digit number for month and day
+      let month = ("0" + (date.getMonth() + 1)).slice(-2);
+      let day = ("0" + (date.getDay() + 1)).slice(-2);
+      // Format the string in the way ALKiln can read it
+      return `${ month }/${ day }/${ date.getFullYear() }`;
+    },
+    currency: async function ( scope ) {
+      return `${ Math.random() * 100 }`;
+    },
+    email: async function ( scope ) {
+      return faker.internet.email( faker.random.word(), faker.random.word(), `example.com` );
+    },
+    password: async function ( scope ) {
+      return faker.internet.password();
+    },
+    hidden: async function ( scope ) {
+      return null;
+    },
+    BirthDate: async function ( scope ) {
+      let date = faker.date.birthdate({ max: 70, min: 0, mode: `age` });
+      // Ensure 2-digit number for month and day
+      let month = ("0" + (date.getMonth() + 1)).slice(-2);
+      let day = ("0" + (date.getDay() + 1)).slice(-2);
+      // Format the string in the way ALKiln can read it
+      let date_str = `${ month }/${ day }/${ date.getFullYear() }`;
+      return date_str;
+    },
+    ThreePartsDate: async function ( scope ) {
+      return await scope.get_random_input_for.date( scope );
+    },
+  },  // ends scope.get_random_input_for()
+
 
   //#####################################
   //#####################################

package/lib/steps.js

@@ -458,7 +458,7 @@ Then(/I take a screenshot ?(?:named "([^"]+)")?/, { timeout: -1 }, async ( name
 /* Here to make writing tests more comfortable. */
 When("I do nothing", async () => { await scope.afterStep(scope); });  // √
 
-Then('the question id should be {string}', { timeout: -1 }, async ( question_id ) => {
+Then(/the (?:question|page|screen) id should be "([^"]+)"/i, { timeout: -1 }, async ( question_id ) => {
   /* Looks for a sanitized version of the question id as it's written
   *     in the .yml. docassemble's way */
   let { question_has_id, id, id_matches } = await scope.examinePageID( scope, question_id );
@@ -780,10 +780,107 @@ When(/I check all pages for (?:accessibility|a11y) issues/i, {timeout: -1}, asyn
 // UI element interaction
 //#####################################
 
+// -------------------------------------
+// --- RANDOM INPUT ---
+When(/I answer randomly for at most ([0-9]+) (?:page(?:s)?|screen(?:s)?)/, { timeout: -1 }, async ( max_pages_str ) => {
+  /** Give random answers until the user can't continue any more.
+  * 
+  * Variations:
+  * I answer randomly for at most 1 page
+  * I answer randomly for at most 10 pages
+  * I answer randomly for at most 101 screens
+  */
+  scope.paths.random_screenshots = `${ scope.paths.scenario }/random_answers_screenshots`;
+  fs.mkdirSync( scope.paths.random_screenshots );
+
+  // Force the dev to prevent infinite loops
+  let max_pages = parseInt( max_pages_str );
+  let curr_page_num = 0;
+
+  // While a continue button is on the current page, fill out
+  // the fields and then try to continue
+  // let continue_exists = true;
+  // while ( continue_exists && curr_page_num < max_pages ) {
+  let buttons_exist = true;
+  while ( buttons_exist && curr_page_num < max_pages ) {
+
+    curr_page_num = curr_page_num + 1;
+    let { id } = await scope.examinePageID( scope, `no target id` );
+
+    // Ensure no infinite loop, but each page has a full timeout to run
+    let custom_timeout = new Promise(async function( resolve, reject ) {
+
+      // Set up timeout to stop infinite loops
+      let page_timeout_id = setTimeout(async function() {
+        
+        let timeout_message = `The page with an id of "${ id }" took too long `
+          + `to fill it with random answers (over ${ scope.timeout/1000/60 } min).`
+        await scope.addToReport( scope, { type: `error`, value: timeout_message });
+        throw( timeout_message );
+
+      }, scope.timeout);
+
+      // self-invoke an anonymous async function so we don't have to
+      // abstract the details of resolving and rejecting.
+      (async function() {
+        try {
+
+          // Set all the fields on the page
+          let buttons = await scope.steps.set_random_page_vars( scope );
+
+          // Take a screenshot of the page before continuing or ending
+          await scope.page.screenshot({
+            path: `${ scope.paths.random_screenshots }/${ Date.now() }.jpg`,
+            type: `jpeg`,
+            fullPage: true
+          });
+
+          // Prep for the next loop to possibly stop. Signature page buttons
+          // don't count as buttons in the way our field detects them
+          buttons_exist = buttons.length > 0;
+          // If there were any buttons, pick a random one to try to press
+          if ( buttons_exist ) {
+            await scope.set_random_input_for.buttons( scope, { fields: buttons });
+          } else {
+            // If can theoretically continue, try to. Also prep to
+            // stop or continue for the next loop
+            buttons_exist = await scope.continue_exists( scope );
+            if ( buttons_exist ) {
+              await scope.continue( scope );
+            }  // ends if continue exists
+          }
+
+          if ( buttons_exist ) {
+            process.stdout.write(`\x1b[36m${ 'v' }\x1b[0m`);  // pressed button
+          }         
+
+          resolve();
+
+        } catch ( err ) {
+          let err_msg = `The page with the "${ id }" errored when trying to fill `
+            + `it with random answers: ${ err.name }`
+          await scope.addToReport( scope, { type: `error`, value: err_msg });
+          throw( err );
+
+        } finally {
+          // prevent temporary hang at end of tests
+          clearTimeout( page_timeout_id );
+        }
+      })();
+
+    });  // ends custom_timeout for set_random_page_vars
+
+    await custom_timeout;
+
+  }  // ends while continue_exists
+
+
+});  // Ends random input
+
 // -------------------------------------
 // --- VARIABLES-BASED STEPS ---
 
-When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( var_name, set_to ) => {
+When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async ( var_name, answer ) => {
   /* Set a non-story table variable (with or without a choice associated with it) to a value. Set:
   *  - Buttons associated with variables
   *  - Dropdowns
@@ -797,7 +894,7 @@ When(/I set the var(?:iable)? "([^"]+)" to "([^"]+)"/, { timeout: -1 }, async (
   * 1. I set the var "rent_interval" to "weekly"
   */
   return wrapPromiseWithTimeout(
-    scope.steps.set_regular_var( scope, var_name, set_to ),
+    scope.steps.set_regular_var( scope, var_name, answer ),
     scope.timeout
   );
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "4.6.2",
+  "version": "4.7.0",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
@@ -37,6 +37,7 @@
   "dependencies": {
     "@axe-core/puppeteer": "4.4.2",
     "@cucumber/cucumber": "7.3.2",
+    "@faker-js/faker": "^7.3.0",
     "axios": "0.24.0",
     "chai": "4.2.0",
     "cheerio": "1.0.0-rc.10",

package/tests/features/interactive_steps.feature

@@ -131,4 +131,9 @@ Scenario: tap element with an error
   is there a typo?
   """
   Given I start the interview at "test_taps"
-  And I tap the "Tests-not_there-tab" tab
+  And I tap the "Tests-not_there-tab" tab
+
+@i5 @random
+Scenario: I answer randomly till the end
+  Given I start the interview at "all_tests"
+  And I answer randomly for at most 50 pages

package/tests/features/random_input.feature

@@ -0,0 +1,15 @@
+@random_input
+Feature: Assembly Line package-specific Steps
+
+# In tag names, 'ri' is for 'random input'
+
+@slow @ri1 @random
+Scenario: I fill in random input till the end
+  Given I start the interview at "test_random_input"
+  And I answer randomly for at most 20 pages
+  Then the question id should be "end"
+
+@slow @ri2 @random
+Scenario: I fill in random input for 1 page
+  Given I start the interview at "test_random_input"
+  And I answer randomly for at most 1 page