@suffolklitlab/alkiln 5.12.0-delete1 → 5.12.0-delete3

package/.github/workflows/github_server.yml

@@ -81,6 +81,11 @@ jobs:
         run: |
           echo "USER1_EMAIL=${{ steps.github_server.outputs.DA_ADMIN_EMAIL }}" >> $GITHUB_ENV
           echo "USER1_PASSWORD=${{ steps.github_server.outputs.DA_ADMIN_PASSWORD }}" >> $GITHUB_ENV
+          echo "USER_NO_PERMISSIONS_EMAIL=${{ steps.github_server.outputs.DA_ADMIN_EMAIL }}" >> $GITHUB_ENV
+          echo "USER_NO_PERMISSIONS_PASSWORD=${{ steps.github_server.outputs.DA_ADMIN_PASSWORD }}" >> $GITHUB_ENV
+          echo "USER_NO_PERMISSIONS_API_KEY=${{ steps.github_server.outputs.DOCASSEMBLE_DEVELOPER_API_KEY }}" >> $GITHUB_ENV
+          echo "INVALID_API_KEY=invalidAPIkey" >> $GITHUB_ENV
+          echo "EMPTY_STRING=''" >> $GITHUB_ENV
 
       #### Developer note:
       #### Example of working with the docker container after it's been

package/.github/workflows/playground.yml

@@ -43,6 +43,11 @@ jobs:
       PLAYGROUND_ID: ${{ secrets.PLAYGROUND_ID }}
       USER1_EMAIL: ${{ secrets.USER1_EMAIL }}
       USER1_PASSWORD: ${{ secrets.USER1_PASSWORD }}
+      USER_NO_PERMISSIONS_EMAIL: ${{ secrets.USER_NO_PERMISSIONS_EMAIL }}
+      USER_NO_PERMISSIONS_PASSWORD: ${{ secrets.USER_NO_PERMISSIONS_PASSWORD }}
+      USER_NO_PERMISSIONS_API_KEY: ${{ secrets.USER_NO_PERMISSIONS_API_KEY }}
+      INVALID_API_KEY: invalidAPIkey
+      EMPTY_STRING: ""
       SECRET_VAR1: secret-var1-value
       SECRET_VAR2: secret-var2-value
       SECRET_FOR_MISSING_FIELD: secret for missing field

package/CHANGELOG.md

@@ -51,11 +51,12 @@ Format:
 
 ### Fixed
 
-- Now delete interviews upon interview completion
+- Now ALKiln deletes interviews upon interview completion for [signed in users](https://assemblyline.suffolklitlab.org/docs/alkiln/writing/#sign-in) as long as the user has an API key. Also, the author must have used the ["start interview" Step](https://assemblyline.suffolklitlab.org/docs/alkiln/writing/#start-interview) to get to the interview. Admins can give a regular user an API key with https://docassemble.org/docs/api.html#api_user_user_id_api_post. See [#831](https://github.com/SuffolkLITLab/ALKiln/issues/831).
 
 ### Internal
 
-- Test deleting interviews upon interview completion
+- Test deleting interviews upon interview completion for signed in users.
+- Switch to mostly using a lowest-access-level user account for actually running interviews.
 - Added @temp_error to neutralize tests that are getting undesired errors right now, but which we anticipate being fixed soon. We want to ignore them for a short while. For example, an upstream change temporarily breaking some tests.
 
 ## [5.12.0] - 2024-06-06

package/lib/docassemble/docassemble_api_REST.js

@@ -31,6 +31,27 @@ da.get_dev_id = async function ( timeout ) {
 };  // Ends da.get_dev_id()
 
 
+da.get_api_key_info = async function ( timeout, { api_key = null, server_url = null }) {
+  /** Get information about an API key owned by the user of the given API key. */
+  let options = {
+    method: 'GET',
+    headers: {'X-API-Key': api_key},
+    url: `${ server_url }/api/user/api`,
+    params: {
+      api_key: api_key,
+    },
+    timeout: timeout,
+  };
+
+  try {
+    return await axios.request( options );
+  } catch (error) {
+    let response = error.response || { data: null }
+    throw {...error.toJSON(), data: response.data};
+  }
+};  // Ends da.get_api_key_info()
+
+
 // node -e 'require("./lib/docassemble/docassemble_api_REST.js").delete_project()'
 da.delete_project = async function ( timeout ) {
   /* Delete a project on the user's da server. */
@@ -54,16 +75,16 @@ da.delete_project = async function ( timeout ) {
 
 
 // node -e 'require("./lib/docassemble/docassemble_api_REST.js").delete_interview(...)'
-da.delete_interview = async function ( timeout, { uid = null }) {
+da.delete_interview = async function ( timeout, { session = null, api_key = null }) {
   /* Delete an interview with the given session id. */
   let options = {
     method: 'DELETE',
-    headers: { 'X-API-Key': session_vars.get_dev_api_key() },
+    headers: { 'X-API-Key': api_key },
     // Can't use `api/session` that uses the API key to identify the user's
     // interview sessions. The test may have signed in with an account
     // that's different than the ALKiln dev account that sends this request.
-    url: `${ session_vars.get_da_server_url() }/api/interviews`,
-    params: { session: uid },
+    url: `${ session_vars.get_da_server_url() }/api/user/interviews`,
+    params: { session },
     timeout: timeout,
   };
 
@@ -76,16 +97,16 @@ da.delete_interview = async function ( timeout, { uid = null }) {
 };  // Ends da.delete_interview()
 
 // node -e 'require("./lib/docassemble/docassemble_api_REST.js").get_interview(...)'
-da.get_interview = async function ( timeout, { uid = null }) {
+da.get_interview = async function ( timeout, { session = null, api_key = null }) {
   /* Get a specific interview. */
   let options = {
     method: 'GET',
-    headers: { 'X-API-Key': session_vars.get_dev_api_key() },
+    headers: { 'X-API-Key': api_key },
     // Can't use `/api/user/interviews` that uses the API key to identify the user's
     // interview sessions. The test may have signed in with an account
     // that's different than the ALKiln dev account that sends this request.
-    url: `${ session_vars.get_da_server_url() }/api/interviews`,
-    params: { session: uid },
+    url: `${ session_vars.get_da_server_url() }/api/user/interviews`,
+    params: { session },
     timeout: timeout,
   };
 

package/lib/docassemble/docassemble_api_interface.js

@@ -177,6 +177,67 @@ da_i.get_dev_id = async function ( dev_id_options ) {
   return dev_id;
 };  // Ends da_i.get_dev_id();
 
+da_i.get_api_key_access_status = async function ({ timeout = null, api_key = null }) {
+  /** Check if the API key has minimal authorization on the server.
+  *    See https://docassemble.org/docs/api.html#api_user_api_get.
+  *
+  * @param options {obj} Options for getting authorization of the API key
+  * @param options.api_key {str | null} Required. The API key to test.
+  * @param options.timeout {int | null} Optional. Max MS
+  *    to allow for server request.
+  */
+
+  let auth_data = {
+    codes: [ 1 ],
+    has_auth: null,
+    messages: [`API key authorization is not yet determined.`],
+    error: null
+  }
+
+  // Skip this for tests run from ALKilnInThePlayground
+  if ( session_vars.get_origin() === 'playground' ) {
+    auth_data.codes.push( 2 );
+    auth_data.messages.push( `API keys are unnecessary for tests run in the Playground.` );
+  }
+
+  if ( typeof api_key !== `string` ) {
+    auth_data.codes.push( 3 );
+    auth_data.messages.push( `The given API key is not a string. Type: ${ typeof api_key }`);
+  }
+
+  if ( auth_data.codes.length === 1 ) {
+    // Default timeouts
+    timeout = timeout || DEFAULT_MAX_REQUEST_MS;
+    try {
+      let response = await _da_REST.get_api_key_info( timeout, {
+        api_key,
+        server_url: session_vars.get_da_server_url(),
+      });
+      auth_data.has_auth = true;
+      auth_data.codes = [ 6 ];
+      auth_data.messages = [ `This API key has at least basic authorization on this server.` ];
+
+    } catch ( error ) {
+      auth_data.error = error;
+      if ( error.status === 403 ) {
+        auth_data.has_auth = false;
+        auth_data.codes = [ 4 ];
+        auth_data.messages = [ `This API is unverified on this server. It is probably missing or has been deleted.` ];
+      } else {
+        // Note on 404, non-existent key: 404 == 403 - Since we're using the
+        // key itself to get its own info, if it doesn't exist, we'll get 403
+        auth_data.codes = [ 5 ];
+        auth_data.messages = [ `This API key threw a non-403 error.` ];
+      }  // ends error status
+    }  // ends try
+  }  // ends auth_data.codes only has the first code
+
+  log.debug({ type: `da api info`, code: `ALK0202`,
+    pre: `API key authentication info`, data: auth_data });
+
+  return auth_data;
+};  // Ends da_i.get_api_key_access_status()
+
 // node -e 'require("./lib/docassemble/docassemble_api_interface.js").delete_project( "create1" )'
 da_i.delete_project = async function ( delete_options ) {
   /** Delete a project on the user's da server. Do we need to watch
@@ -201,48 +262,75 @@ da_i.delete_project = async function ( delete_options ) {
 };  // Ends da_i.delete_project()
 
 // node -e 'require("./lib/docassemble/docassemble_api_interface.js").quietly_try_to_delete_interviews(...)'
-da_i.quietly_try_to_delete_interviews = async function ({ interviews = {}, options = {} }) {
-  /** Delete a user's interview. Do we need to watch for a timeout? */
+da_i.quietly_try_to_delete_interviews = async function ({ interviews = {}, api_keys = [], options = {} }) {
+  /** Try to delete the given interviews. Fail silently. Example failure: the test
+   *    did not log in any users and the testing account's role prevents
+   *    access to other user's interviews. Do we need to watch for a timeout? */
 
   // Defaults
   let { timeout } = options || { timeout: DEFAULT_MAX_REQUEST_MS };
 
+  let responses = [];
   for ( let id in interviews ) {
-    let interview_vars = interviews[ id ];
-    if ( interview_vars && interview_vars.uid ) {
-      try {
-        log.debug({ type: `da api info`, code: `ALK0188`, pre: `Trying to delete the interview with the id ${ interview_vars.uid }.` });
-
-        // Actual work:
-        let response = await _da_REST.delete_interview( timeout, interview_vars );
-        log.debug({ type: `da api info`, code: `ALK0189`,
-          pre: `No error when trying to delete interview ${ interview_vars.uid } at ${ interview_vars.i }.`
-        });
-
-      } catch ( error ) {
-        error.interview_vars = interview_vars;
-        let msg = `Error when deleting the interview. See https://docassemble.org/docs/api.html#session_delete.`
-        log.debug({ type: `da api info`, code: `ALK0190`, pre: msg, data: error });
-      }
+    let interview = interviews[ id ];
+    if ( interview && interview.uid ) {
+      let sub_responses = await da_i.quietly_delete_one_interview( timeout, {
+        interview,
+        api_keys
+      });
+      responses.push( sub_responses );
     } else {
       log.debug({ type: `da api info`, code: `ALK0191`, pre: `There is no interview to delete.` });
     }
   }
+  return responses;
 
 };  // Ends da_i.quietly_try_to_delete_interviews()
 
+// node -e 'require("./lib/docassemble/docassemble_api_interface.js").quietly_delete_one_interview(...)'
+da_i.quietly_delete_one_interview = async function ( timeout, { interview = {}, api_keys = [] }) {
+  /** Try to delete an interview using all available API keys. Fail silently.
+   *    Example failure: the test did not log in any users and the testing
+   *    account's role prevents access to other user's interviews. */
+  api_keys = normalize_api_keys( api_keys );
+  let responses = [];
+  for ( let api_key of api_keys ) {
+    try {
+      log.debug({ type: `da api info`, code: `ALK0188`,
+        pre: `Trying to delete the interview with the id ${ interview.uid } and an API key.`
+      });
+
+      // Actual work:
+      let response = await _da_REST.delete_interview( timeout, {
+        session: interview.uid,
+        api_key
+      });
+      responses.push( response );
+
+      log.debug({ type: `da api info`, code: `ALK0189`,
+        pre: `No error when trying to delete interview ${ interview.uid } at ${ interview.i }.`
+      });
+    } catch ( error ) {
+      error.interview = interview;
+      let msg = `Error when deleting the interview. See https://docassemble.org/docs/api.html#session_delete.`
+      log.debug({ type: `da api info`, code: `ALK0190`, pre: msg, data: error });
+    }
+  }  // ends for api keys
+  return responses;
+};  // Ends da_i.quietly_delete_one_interview()
+
 // node -e 'require("./lib/docassemble/docassemble_api_interface.js").get_interviews(...)'
-da_i.get_interviews = async function ({ interviews = {}, options = {} }) {
+da_i.get_interviews = async function ({ interviews = {}, api_keys = [], options = {} }) {
   /** Return an object of interviews that exist on the server
    *    that match the given interviews. Keys are the session ids. */
-  // Defaults
-  let { timeout } = options || { timeout: DEFAULT_MAX_REQUEST_MS };
+
+  api_keys = normalize_api_keys( api_keys );
 
   let fetched_interviews = {};
   if ( interviews ) {
     for ( let id in interviews ) {
-      let interview_vars = interviews[ id ];
-      let fetched = await da_i.get_interview({ interview_vars });
+      let interview = interviews[ id ];
+      let fetched = await da_i.get_interview({ interview, api_keys, options });
       if ( fetched && fetched.session ) {
         fetched_interviews[ fetched.session ] = fetched;
       }
@@ -253,30 +341,37 @@ da_i.get_interviews = async function ({ interviews = {}, options = {} }) {
 };  // Ends da_i.get_interviews()
 
 // node -e 'require("./lib/docassemble/docassemble_api_interface.js").get_interview(...)'
-da_i.get_interview = async function ({ interview_vars, options = {} }) {
+da_i.get_interview = async function ({ interview = {}, api_keys = [], options = {} }) {
   /** Try to get an interview from the server that matches the given interview data. */
 
   // Defaults
   let { timeout } = options || { timeout: DEFAULT_MAX_REQUEST_MS };
+  api_keys = normalize_api_keys( api_keys );
 
-  if ( interview_vars && interview_vars.uid ) {
-    try {
-      log.debug({ type: `da api info`, code: `ALK0192`, pre: `Trying to get the interview with the id ${ interview_vars.uid }.` });
+  if ( interview && interview.uid ) {
+    for ( let api_key of api_keys ) {
+      try {
+        log.debug({ type: `da api info`, code: `ALK0192`, pre: `Trying to get the interview with the id ${ interview.uid } and an API key.` });
 
-      // Actual work:
-      let response = await _da_REST.get_interview( timeout, interview_vars );
-      if ( response && response.data && response.data.items && response.data.items[0] && response.data.items[0].session ) {
-        log.debug({ type: `da api info`, code: `ALK0193`, pre: `Status ${ response.status }. Got ${ response.data.items[0].session }.`});
-        return response.data.items[0];
-      } else {
-        log.debug({ type: `da api info`, code: `ALK0194`, pre: `Status ${ response.status }. Cannot find ${ interview_vars.uid }`});
-      }
+        // Actual work:
+        let response = await _da_REST.get_interview( timeout, {
+          session: interview.uid,
+          api_key
+        });
 
-    } catch ( error ) {
-      error.interview_vars = interview_vars;
-      let msg = `${ error.status } "${ error.statusText }" Ran into an error when getting the interview ${ interview_vars.uid }. See https://docassemble.org/docs/api.html#interviews.`
-      log.debug({ type: `da api info`, code: `ALK0195`, pre: msg, data: error });
-    }
+        if ( response && response.data && response.data.items && response.data.items[0] && response.data.items[0].session ) {
+          log.debug({ type: `da api info`, code: `ALK0193`, pre: `Status ${ response.status }. Got ${ response.data.items[0].session }.`});
+          return response.data.items[0];
+        } else {
+          log.debug({ type: `da api info`, code: `ALK0194`, pre: `Status ${ response.status }. Cannot find ${ interview.uid }`});
+        }
+
+      } catch ( error ) {
+        error.interview = interview;
+        let msg = `${ error.status || `No error.status.` } ${ error.statusText || error.data || `No error.statusText.` } Ran into an error when getting the interview ${ interview.uid }. See https://docassemble.org/docs/api.html#interviews.`
+        log.debug({ type: `da api info`, code: `ALK0195`, pre: msg, data: error });
+      }
+    }  // ends for api_keys
   } else {
     log.debug({ type: `da api info`, code: `ALK0196`, pre: `There is no interview to get.` });
   }
@@ -284,3 +379,11 @@ da_i.get_interview = async function ({ interview_vars, options = {} }) {
   return null;
 
 };  // Ends da_i.get_interview()
+
+let normalize_api_keys = function ( api_keys = [] ) {
+  /** Ensure the dev API key is in the api_keys list. */
+  let dev_key = session_vars.get_dev_api_key();
+  if ( !api_keys ) { api_keys = [ dev_key ]; }
+  if ( !api_keys.includes( dev_key ) ) { api_keys.unshift( dev_key ); }
+  return api_keys;
+};

package/lib/scope.js

@@ -16,7 +16,7 @@ const time = require('./utils/time');
 const log = require('./utils/log');
 const { waitForTimeout } = require('./utils/time');
 const files = require('./utils/files' );
-const server = require('./docassemble/docassemble_api_interface');
+const da_api = require('./docassemble/docassemble_api_interface');
 const wrapPromiseWithTimeout = require('./cucumber_8_shim');
 const reports = require(`./utils/reports`);
 
@@ -339,7 +339,7 @@ module.exports = {
       // This code assumes a reasonable response time would be n seconds if the
       // server is up and that a server reload/restart won't take less than n seconds.
       // Also, it's non-blocking, so it doesn't slow down tests
-      let is_up = await server.is_server_responding({ timeout: scope.server_check_interval_ms });
+      let is_up = await da_api.is_server_responding({ timeout: scope.server_check_interval_ms });
       // Add status to the beginning of the list to make truncating easier
       scope.server_statuses.unshift( is_up );
 
@@ -2938,7 +2938,9 @@ module.exports = {
       await scope.afterStep(scope, {waitForShowIf: true});
     },  // Ends scope.steps.set_al_address()
 
-    sign_in: async function ( scope, { email_secret_name, password_secret_name }) {
+    sign_in: async function ( scope, {
+      email_secret_name, password_secret_name, api_key_secret_name
+    }) {
       /** Allow the developer to log a user into their server using GitHub
       * secrets to authenticate.
       */
@@ -2991,6 +2993,26 @@ module.exports = {
       if ( password === undefined ) {
         reports.addToReport( scope, { type: `error`, code: `ALK0162`, value: password_msg })
       }
+      // Save API key to clean up interviews later. Nice to have, not critical
+      if ( api_key_secret_name ) {
+        let api_key = process.env[ api_key_secret_name ];
+        let api_key_msg = `The API key called "${ api_key_secret_name }" is missing. Check for a typo in your test, workflow file, GitHub secret, or server config.`
+        if ( api_key === undefined ) {
+          reports.addToReport( scope, { type: `warning`, code: `ALK0199`, value: api_key_msg });
+        } else if ( api_key === `` ) {
+          reports.addToReport( scope, { type: `warning`, code: `ALK0200`,
+            value: `ALKiln found the API key called "${ api_key_secret_name }", but it was empty. It had no text in it. Edit the value of the GitHub secret or server config variable called "${ api_key_secret_name }".` });
+        } else {
+          let access_info = await da_api.get_api_key_access_status({ api_key });
+          if ( !access_info.has_auth ) {
+          reports.addToReport( scope, { type: `warning`, code: `ALK0201`,
+            value: `The server rejected the API key called "${ api_key_secret_name }". Does it exist on this server? Was it deleted somehow? You can always make a new one.` });
+          }
+          // Even if it doesn't have access, give it a shot anyway.
+          // Maybe we got something wrong.
+          scope.scenarios.get( scope.scenario_id ).api_keys.push( api_key );
+        }
+      }
 
       expect( email, email_msg ).to.not.equal( undefined );
       expect( password, password_msg ).to.not.equal( undefined );

package/lib/steps.js

@@ -140,6 +140,7 @@ Before(async (scenario) => {
   scope.scenario_id = uuidv4();
   scope.scenarios.set( scope.scenario_id, {} );
   scope.scenarios.get( scope.scenario_id ).interviews = {};
+  scope.scenarios.get( scope.scenario_id ).api_keys = [ session_vars.get_dev_api_key() ];
   scope.expected_status = null;
   scope.expected_in_report = null;
   scope.expected_not_in_report = null;
@@ -280,21 +281,27 @@ Given(/I go to "([^"]+)"/i, {timeout: -1}, async ( url ) => {
   return result;
 });
 
-Given(/I (?:sign|log) ?(?:in)?(?:on)?(?:to the server)? with(?: the email)? "([^"]+)" and(?: the password)? "([^"]+)"(?: SECRETs)?/i, {timeout: -1}, async ( email, password ) => {
+Given(
+  /I (?:sign|log) ?(?:in)?(?:on)?(?:to the server)? with(?: the email)? "([^"]+)",?(?: and)?(?: the password)? "([^"]+)"(?: SECRETs)?(?:,?(?: and)?(?: the API key)? "([^"]+)")?/i,
+  { timeout: -1 },
+  async ( email, password, api_key ) => {
   /** Uses the names of environment variables (most often GitHub SECRETs) to
-  *     log into an account on the user's server. Must be SECRETs to stay secure.
+  *     log into an account on the user's server. Must be secure.
   * 
   * Variations:
-  * I sign into the server with the email "USER1_EMAIL" and the password "USER1_PASSWORD" SECRETs
-  * I sign on with the email "USER1_EMAIL" and the password "USER1_PASSWORD" SECRETs
-  * I log in with "USER1_EMAIL" and "USER1_PASSWORD"
+  * I sign into the server with the email "USER2_EMAIL" and the password "USER2_PASSWORD"
+  * I sign on with the email "USER2_EMAIL" and the password "USER2_PASSWORD"
+  * I log in with "USER2_EMAIL" and "USER2_PASSWORD"
+  * I sign in with the email "USER2_EMAIL", the password "USER2_PASSWORD", and the API key "USER2_API_KEY"
+  * I sign in with "USER2_EMAIL", "USER2_PASSWORD", "USER2_API_KEY"
   */
   // `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, {
     email_secret_name: email,
-    password_secret_name: password
+    password_secret_name: password,
+    api_key_secret_name: api_key
   });
 });
 
@@ -1190,24 +1197,26 @@ Then(/of two interviews, I delete one __internal__/i, async () => {
    */
   // Make sure we have two interviews in `scope.scenario.interviews` (two session ids)
   let interviews = scope.scenarios.get( scope.scenario_id ).interviews;
-  let internal_keys = Object.keys( interviews );
+  let interview_keys = Object.keys( interviews );
   expect(
-    internal_keys.length,
-    `Of 2 interview sessions, ALKiln only saved ${ internal_keys.length }`
+    interview_keys.length,
+    `Of 2 interview sessions, ALKiln only saved ${ interview_keys.length }`
   ).to.equal( 2 );
 
   // Check that both interviews exist on the server. 1 √ 2 √
-  let existing_interviews = await da_api.get_interviews({ interviews });
-  let existing_keys = Object.keys( existing_interviews );
+  let api_keys = scope.scenarios.get( scope.scenario_id ).api_keys;
+  let visible_interviews = await da_api.get_interviews({ interviews, api_keys });
+  let visible_keys = Object.keys( visible_interviews );
   expect(
-    existing_keys.length,
-    `2 interviews should be on the server. Instead: ${ existing_keys.join(', ') }`
+    visible_keys.length,
+    `2 interviews should be on the server. Instead: "${ visible_keys.join(', ') }"`
   ).to.equal( 2 );
 
   // Delete one. 1 x 2 √
-  let to_delete = interviews[ internal_keys[ 0 ]];
+  let to_delete = interviews[ interview_keys[ 0 ]];
   await da_api.quietly_try_to_delete_interviews({
-    interviews: { [internal_keys[ 0 ]]: to_delete }
+    interviews: { [interview_keys[ 0 ]]: to_delete },
+    api_keys
   });
 
   // Check that only one session exists on the server. This tests that
@@ -1215,7 +1224,7 @@ Then(/of two interviews, I delete one __internal__/i, async () => {
   // 2. We are fetching interviews correctly because we are getting one
   // back (e.g. not passing null into the api function)
   // 1 x 2 √
-  let after_deletion = await da_api.get_interviews({ interviews });
+  let after_deletion = await da_api.get_interviews({ interviews, api_keys });
   let keys_after_deletion = Object.keys( after_deletion );
   expect(
     keys_after_deletion.length,
@@ -1224,16 +1233,28 @@ Then(/of two interviews, I delete one __internal__/i, async () => {
   // In After(), the other session should get deleted
 });
 
-// Then(/there are no interview_vars saved __internal__/i, async () => {
-//   /** Test that no interviews were saved internally */
-//   // Check the number of interviews
-//   let interviews = scope.scenarios.get( scope.scenario_id ).interviews;
-//   let keys = Object.keys( interviews );
-//   expect(
-//     keys.length,
-//     `0 interviews should exist, but at least one does: ${ keys.join(', ') }`
-//   ).to.equal( 0 );
-// });
+Then(/I fail to delete (\d) detected interview(?:s)? and get no error __internal__/i, async ( num ) => {
+  /** Test that there is no error when ALKiln is unable to delete an interview. */
+  num = parseInt( num );
+  // Make sure we started an interview
+  let interviews = scope.scenarios.get( scope.scenario_id ).interviews;
+  expect(
+    Object.keys( interviews ).length,
+    `The test should have saved ${ num } interview session(s)`
+  ).to.equal( num );
+
+  // There should be no error about an unauthorized user
+  let api_keys = scope.scenarios.get( scope.scenario_id ).api_keys;
+  let visible_interviews = await da_api.get_interviews({ interviews, api_keys });
+  let visible_keys = Object.keys( visible_interviews );
+  expect(
+    visible_keys.length,
+    `User should detect 0 interviews on the server. Instead: "${ visible_keys.join(', ') }"`
+  ).to.equal( 0 );
+
+  // Deleting with an anonymous user should fail silently
+  await da_api.quietly_try_to_delete_interviews({ interviews, api_keys });
+});
 
 
 //#####################################
@@ -1446,25 +1467,34 @@ After(async function(scenario) {
 
   // Now that we're no longer on the interview page, one way or
   // another, try to delete the interviews created during the test
-  try {
-    let interviews = scope.scenarios.get( scope.scenario_id ).interviews;
-    await da_api.quietly_try_to_delete_interviews({ interviews });
-    let existing_interviews = await da_api.get_interviews({ interviews });
-    let existing_keys = Object.keys( existing_interviews );
-    // Deleting interviews is nice, but not non-critical. Don't bother the
-    // user with it. Don't want to cover up a more meaningful failure (like
-    // going to the wrong file). If it becomes a problem we can track it down later.
-    if ( existing_keys.length > 0 ) {
-      log.debug({ type: `internal warning`, code: `ALK0197`,
-        pre: `${ existing_keys.length } interviews were not deleted: ${ existing_keys.join( ', ' ) }`
-      });
+  // Authors running this manually get to choose what to do with
+  // the interviews they're creating unless we hear otherwise.
+  if ( session_vars.get_origin() !== `playground` ) {
+    try {
+      let interviews = scope.scenarios.get( scope.scenario_id ).interviews;
+      let api_keys = scope.scenarios.get( scope.scenario_id ).api_keys;
+      await da_api.quietly_try_to_delete_interviews({ interviews, api_keys });
+      let visible_interviews = await da_api.get_interviews({ interviews, api_keys });
+      let visible_keys = Object.keys( visible_interviews );
+      // Deleting interviews is nice, but not non-critical. Don't bother the
+      // user with it. Don't want to cover up a more meaningful failure (like
+      // 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.debug({ type: `internal warning`, code: `ALK0197`,
+          pre: `The API key can see ${ visible_keys.length } interviews that were not deleted: ${ visible_keys.join( ', ' ) }`
+        });
+      }
+    } catch ( error ) {
+      // Deleting interviews is nice, but not non-critical. Don't bother the
+      // user with it. Don't want to cover up a more meaningful failure (like
+      // going to the wrong file). Example of OK failure: the user owns the
+      // interview is different than the API key that's trying to delete the
+      // 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.debug({ type: `internal warning`, code: `ALK0198`, pre: `Error while cleaning up interviews.`, data: error });
     }
-  } catch ( error ) {
-    // Deleting interviews is nice, but not non-critical. Don't bother the
-    // user with it. Don't want to cover up a more meaningful failure (like
-    // going to the wrong file). 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.debug({ type: `internal warning`, code: `ALK0198`, pre: `Error while cleaning up interviews.`, data: error });
   }
 
   // Handle all the accumulated errors

package/package.json

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

package/tests/log_codes/check_codes.sh

@@ -16,7 +16,7 @@ fi
 # The grepped files will include the list of all the codes that have been
 # removed and are no longer used. Syntax used works with GitHub cli ([[:digit:]])
 # https://stackoverflow.com/a/6901221
-lines=$(grep -roh --exclude="tests/log_codes/check_codes.sh" --exclude="debug_log.txt" --exclude="cucumber-report.txt" --exclude-dir="node_modules" --exclude-dir='alkiln-*' --exclude-dir='_alkiln*' 'ALK[[:digit:]][[:digit:]][[:digit:]][[:digit:]]' "$directory")
+lines=$(grep -roh --exclude="tests/log_codes/check_codes.sh" --exclude="debug_log.txt" --exclude="cucumber-report.txt" --exclude-dir="./docassemble" --exclude-dir="node_modules" --exclude-dir='alkiln-*' --exclude-dir='_alkiln*' 'ALK[[:digit:]][[:digit:]][[:digit:]][[:digit:]]' "$directory")
 sorted=$(echo "$lines" | sort -n)