@suffolklitlab/alkiln 5.13.3-feat-random → 5.13.3-feat-random-3

package/.github/workflows/unit_tests.yml

@@ -27,7 +27,7 @@ jobs:
       - run: npm run unit
       # Artifacts
       - name: upload unit tests artifacts folder
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         # This will upload even if a previous step has failed
         if: ${{ always() }}
         with:

package/CHANGELOG.md

@@ -43,7 +43,34 @@ Format:
 - 
 -->
 
-<!-- ## [Unreleased] -->
+## [Unreleased]
+
+### Added
+
+- Add the `constrained random answers` Step. You must put the Step in a "constrained random test generator" Scenario which goes in a "constrained random test generator" file - a `.feature` file that starts with "alkiln_random". The file **MUST have ONLY 1 Scenario per generator file** at the moment. The Step is pretty strict. If there are irregularities, it will probably fail, but it will fail quickly. It is flexible about number of tests, though, and will default to 1. Closes [#962](https://github.com/SuffolkLITLab/ALKiln/issues/962).
+- Add `MAX_RANDOM_TESTS_PER_SCENARIO` optional environment variable for the above `constrained random answers` Step. Default value is `40` until we hear otherwise.
+- Regular tests that have incorrect syntax will fail more quickly now - very near the start. So will invalid "constrained random test generator" files. This will be a little slower for GitHub Sandbox tests right now, but still faster than it has been in the past. Closes [#972](https://github.com/SuffolkLITLab/ALKiln/issues/972).
+
+### Changed
+
+- Improve report indentation and tweak styling.
+- Clarify some logs, including addressing bite-sized issues like [#981](https://github.com/SuffolkLITLab/ALKiln/issues/981).
+- The report now shows the name of every Step that gets run in a test.
+
+### Internal
+
+- Added: `lib/globals.js` file to hold some shared constant values across the framework. It should NOT manage state. We may want to change the name to `constants.js` or `global_contants.js`. Let's see how it serves us.
+- Added: executable scripts for more setup steps - managing the artifacts path (at the start of a run) and validating and generating files.
+- Changed: `Log` now prioritizes what folder it stores files in in this order:
+    1. Use the argument to use an existing folder and save that to runtime_config.json at root.
+    2. Use the argument to make a new folder with that name and save that to runtime_config.json at root.
+    3. Use the alread-existing folder name value in runtime_config.json at root
+    4. Create a new folder and save that to runtime_config.json at root
+- Changed: Add `.error()` to `Log` for visual clarity when storing an error to throw later. We need to discuss this behavior and its return value. To make that work Logs can now get the `error` prop without throwing an error.
+- Changed: the Story Table step now accepts multiple ids and stops at whatever id it reaches first. I highly recommend that only ALKiln generated tests use this feature. We may avoid documenting it unless authors ask for it.
+- Changed: `.gitignore` and `.npmignore` more things
+- Fixed: log codes checker obob.
+- Fixed: updated `actions/upload-artifact@v3` to `actions/upload-artifact@v4`
 
 ## [5.13.4] - 2025-01-11
 

package/action.yml

@@ -106,10 +106,10 @@ runs:
       run: |
         log="💡 ALK0024 INFO: Confirm environment variables"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-        vars_log='\nALKiln version is $ALKILN_VERSION\nRepo is "$REPO_URL"\nBranch ref is "$BRANCH_PATH"\nCustom MAX_SECONDS_FOR_SETUP is "$MAX_SECONDS_FOR_SETUP"\nCustom SERVER_RELOAD_TIMEOUT_SECONDS is "$SERVER_RELOAD_TIMEOUT_SECONDS"\nCustom MAX_RANDOM_TESTS_PER_SCENARIO is "$MAX_RANDOM_TESTS_PER_SCENARIO"\n'
+        vars_log='\nALKiln version is ${{ env.ALKILN_VERSION }}\nRepo is "${{ env.REPO_URL }}"\nBranch ref is "${{ env.BRANCH_PATH }}"\nCustom MAX_SECONDS_FOR_SETUP is "${{ env.MAX_SECONDS_FOR_SETUP }}"\nCustom SERVER_RELOAD_TIMEOUT_SECONDS is "${{ env.SERVER_RELOAD_TIMEOUT_SECONDS }}"\nCustom MAX_RANDOM_TESTS_PER_SCENARIO is "${{ env.MAX_RANDOM_TESTS_PER_SCENARIO }}"\n'
         echo -e "$vars_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$vars_log"
 
-    # Install ALKiln into GitHub workflow
+    # Install ALKiln during GitHub workflow
     - name: "💡 ALK0025 INFO: Set up node"
       uses: actions/setup-node@v4
       with:
@@ -122,19 +122,17 @@ runs:
         npm install -g "@suffolklitlab/alkiln@$ALKILN_VERSION"
 
     # Files prep
-
     - shell: bash
       env:
         ARTIFACT_FOLDER: ${{ env.ARTIFACT_FOLDER }}
       run: |
-        log="💡 ALK0273 INFO: Prepare repository test files"
+        log="💡 ALK0275 INFO: Prepare repository test files"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         alkiln-artifacts --path="${{ env.ARTIFACT_FOLDER }}"
         alkiln-validate
         alkiln-generate
 
     # Install package on playground
-
     # Don't rely on the environment's version of python
     - uses: actions/setup-python@v5
       if: ${{ inputs.INSTALL_METHOD == 'playground' }}
@@ -156,15 +154,15 @@ runs:
         long_log="\n\n―――\n🤕 ALK0028 ERROR: Unable to create a Project on your server's testing account or pull your package into it. Check the messages above this line.\n\n"
         echo -e "$long_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$long_log"
 
-    # Server installations - find folders and save session vars
-    - name: "💡 ALK0029 INFO: Install the GitHub package onto the server"
+    # Server installation
+    - name: "💡 ALK0029 INFO: Try to install the GitHub package onto the GitHub sandbox server"
       if: ${{ inputs.INSTALL_METHOD == 'server' }}
       shell: bash
       run: |
         log="💡 ALK0029 INFO: Install the GitHub package onto the server"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         alkiln-server-install
-    - name: "🤕 ALK0030 ERROR: Unable to install the package"
+    - name: "🤕 ALK0030 ERROR: Unable to install the package on the GitHub sandbox server"
       if: ${{ inputs.INSTALL_METHOD == 'server' && failure() }}
       shell: bash
       run: |

package/action_for_github_server/action.yml

@@ -51,36 +51,28 @@ runs:
         run: |
           log="💡 ALK0018 INFO: Get path names with date and time"
           timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
+          # Where to get the contents for the artifact
           debug_dir="/tmp"
-          debug_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
+          debug_logs_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
+          # Where to put the artifact
           artifact_folder="alkiln_github_server-${timestamp}UTC"
+          echo "debug_logs_path: $debug_logs_path"
+          echo "artifact_folder: $artifact_folder"
 
           mkdir -p "$debug_dir"
           mkdir -p "$artifact_folder"
-          echo -e "$log" >> "$debug_path"
+          echo -e "$log" >> "$debug_logs_path"
 
-          echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
+          echo "DEBUG_LOGS_PATH=$debug_logs_path" >> $GITHUB_ENV
           echo "GITHUB_SERVER_ARTIFACT_NAME=$artifact_folder" >> $GITHUB_ENV
 
-      - shell: bash
-        env:
-          GITHUB_SERVER_ARTIFACT_NAME: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-        run: |
-          log="💡 ALK0276 INFO: Prepare repository test files"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-          alkiln-artifacts --path="${{ env.GITHUB_SERVER_ARTIFACT_NAME }}"
-          alkiln-validate
-          alkiln-generate
-
-          # These run twice. As before, this creates 2 artifact folders.
-
       - shell: bash
         env:
           MAX_SECONDS_FOR_DOCKER: ${{ inputs.MAX_SECONDS_FOR_DOCKER }}
           DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
         run: |
           log="💡 ALK0001 INFO: Set environment variables"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           echo "MAX_SECONDS_FOR_DOCKER=$MAX_SECONDS_FOR_DOCKER" >> $GITHUB_ENV
           echo "DOCASSEMBLECLI_VERSION=$DOCASSEMBLECLI_VERSION" >> $GITHUB_ENV
@@ -93,7 +85,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0002 INFO: Create GitHub step output variables"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           echo "DOCASSEMBLE_DEVELOPER_API_KEY=$DA_ADMIN_API_KEY" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_EMAIL=$DA_ADMIN_EMAIL" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_PASSWORD=$DA_ADMIN_PASSWORD" >> "$GITHUB_OUTPUT"
@@ -104,19 +96,19 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0003 INFO: Get config"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           mkdir /tmp/config
           # Worth making this silent by defining a variable with > /dev/null...?
           if [ -n "$CONFIG" ]
           then
             log2="💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
-            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" echo "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_LOGS_PATH }}" echo "$log2"
             echo "$CONFIG" > /tmp/config/myconfig.yml
             echo "CONFIG_ARGS=--env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config " >> $GITHUB_ENV
           else
             log3="💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
-            echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" echo "$log3"
+            echo -e "\n$log3" >> "${{ env.DEBUG_LOGS_PATH }}" echo "$log3"
             echo "CONFIG_ARGS=" >> $GITHUB_ENV
           fi
 
@@ -132,13 +124,13 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0006 INFO: Determine docker logs visibility"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             echo "OUTPUT_DOCKER=$SHOW_DOCKER_OUTPUT" >> $GITHUB_ENV
-            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "${{ env.DEBUG_PATH }}"
+            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "${{ env.DEBUG_LOGS_PATH }}"
           else
             echo "OUTPUT_DOCKER=false" >> $GITHUB_ENV
-            echo -e "\nfalse" >> "${{ env.DEBUG_PATH }}"
+            echo -e "\nfalse" >> "${{ env.DEBUG_LOGS_PATH }}"
           fi
 
       # Messages about output
@@ -148,14 +140,14 @@ runs:
         run: |
           # 💡 ALK0007 INFO: ALKiln will now hide docker output
           log="===\n💡 ALK0007 INFO: ALKiln will now hide docker output to avoid possibly showing details about your config. If you want to get output to see more of what is going on, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"true\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
       - name: "💡 ALK0008 INFO: ALKiln will show docker output"
         if: ${{ env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
           # 💡 ALK0008 INFO: ALKiln will show docker output
           log="===\n💡 ALK0008 INFO: ALKiln will show docker output. ALKiln cannot control this output. If you want to prevent output, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"false\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       # TODO: Reduce these to 1 block by putting ` > /dev/null 2>&1` into an env var
       # No docker output
@@ -166,7 +158,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0009 INFO: Download and start docker silently"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           docker pull jhpyle/docassemble > /dev/null 2>&1
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
@@ -183,7 +175,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0010 INFO: Download and start docker"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           docker pull jhpyle/docassemble
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
@@ -201,13 +193,13 @@ runs:
         run: |
           # 💡 ALK0011 INFO: The following messages are not docker output
           log="💡 ALK0011 INFO: The following messages are NOT docker output, just ALKiln waiting for the server to start"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       - name: "💡 ALK0012 INFO: Waiting for server to start"
         shell: bash
         run: |
           log="💡 ALK0012 INFO: Waiting for server to start"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           # Reset the SECONDS variable
           SECONDS=0
@@ -217,27 +209,27 @@ runs:
           response="start"
           while [[ $response != *"200"* ]]; do
             log2="💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
-            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" && echo -e "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log2"
 
             # Check if max seconds till loading has passed
             if [[ $SECONDS -ge $MAX_SECONDS_FOR_DOCKER ]]; then
               log3="🤕 ALK0014 ERROR: Timed out waiting for docker container to serve the site. If you want to give your docker container more timem to install, set the MAX_SECONDS_FOR_DOCKER input for this action."
-              echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" && echo -e "$log3"
+              echo -e "\n$log3" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log3"
               exit 1
             fi
 
             # Set the variable to a new string value in each iteration
             response=$(curl -o /dev/null -s -w "%{http_code}\n" http://localhost:80/health_check?ready=1)
             log4="💡 ALK0015 INFO: Response is $response"
-            echo -e "\n$log4" >> "${{ env.DEBUG_PATH }}" && echo -e "$log4"
+            echo -e "\n$log4" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log4"
 
             # Check if the string includes the desired text
             if [[ $response == *"200"* ]]; then
               log5="💡 ALK0016 SUCCESS: Success! The docker container is ready!"
-              echo -e "\n$log5" >> "${{ env.DEBUG_PATH }}" && echo -e "$log5"
+              echo -e "\n$log5" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log5"
             else
               log6="💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
-              echo -e "\n$log6" >> "${{ env.DEBUG_PATH }}" && echo -e "$log6"
+              echo -e "\n$log6" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log6"
               sleep 30
             fi
 
@@ -272,23 +264,23 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0019 INFO: Create docker artifact data"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
+          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_LOGS_PATH }}"
       - name: "💡 ALK0020 INFO: Upload artifacts folder"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-          path: ${{ env.DEBUG_PATH }}
+          path: ${{ env.DEBUG_LOGS_PATH }}
 
       - shell: bash
         if: ${{ success() }}
         run: |
           log="💡 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       - shell: bash
         if: ${{ failure() }}
         run: |
           log="🤕 ALK0022 ERROR: Something went wrong. See above for more details."
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"

package/lib/docassemble/setup.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-// rename? install_authors_docassemble_interview_package_on_server
-
 const child_process = require(`child_process`);
 
 const Log = require(`../utils/Log`);
@@ -56,7 +54,7 @@ const setup = async () => {
       + `dainstall this package on your server. See above for more details.`;
     log.throw({ code: `ALK0047`, context,
       before: `☝️ ☝️ ☝️  Error data ☝️ ☝️ ☝️\n`,
-      error: `Error while installing project` },
+      error: new Error(`Error while installing project on your docassemble server`) },
       install_err_msg
     );
   }

package/lib/run_cucumber.js

@@ -10,34 +10,29 @@ const Log = require('./utils/Log');
 const session_vars = require('./utils/session_vars');
 const set_sources_paths = require(`./utils/set_sources_paths`);
 
-// TODO: Remove after merging Log class
-const files = require('./utils/files');
-
 const SUMMARY_FILENAME = `cucumber-report.txt`;
 
 
-function build_config( cli_args ) {
+function build_config() {
   /** Use the command line arguments to build the cucumberjs config object.
    * 
    * @param {string?} - Arguments passed to the command line.
    * 
    * @returns {object} - cucumberjs config object
    * */
-  // ========== TODO: Abstract after merging Log class PR
   // Turn all the paths to the sources folders into paths to the feature files
   let sources_paths = session_vars.get_sources_paths();
   let feature_paths = [];
 
   // Get all the paths for the right feature files (for cucumber to use)
   for ( let sources_path of sources_paths ) {
-    // Ignore feature files that we parsed ourselves
     let glob = fast_glob.sync(
       `${ sources_path }/**/*.feature`,
+      // Ignore "generator" feature files that we used to generate actual tests
       { ignore: [`${ sources_path }/${ globals.generators_prefix }*.feature`] }
     );
     feature_paths.push( ...glob );
   }
-  // ========== Ends TODO: Abstract
 
   const config = {
     publishQuiet: true,
@@ -47,6 +42,7 @@ function build_config( cli_args ) {
     retry: 1,
   }
 
+  const cli_args = require(`minimist`)( process.argv.slice(2) );
   // Normalize tag expressions, if there are any
   // Joining and splitting handles both tags surrounded with `""` or those without `""`
   let tags = cli_args[`_`].join(` `).split(` `);
@@ -83,30 +79,6 @@ async function main() {
   log.info({ code: `ALK0049`, context: `pre_run environment` },
     environment
   );
-
-  // ========== TODO: Abstract after merging Log class PR
-  let artifacts_path = files.make_artifacts_folder();
-  session_vars.save_artifacts_path_name( artifacts_path );
-
-  // We'll use the user info to construct the possible paths to /sources
-  let id = session_vars.get_user_id();
-  // `project` is the name in the server docassemble "Project" page
-  let project = session_vars.get_user_project_name();
-
-  // process.argv is a list of strings of commands and args.
-  // If using `npm run cucumber` (as opposed to the bin commands),
-  // use `--` before `--sources=./foo`
-  const argv = require(`minimist`)( process.argv.slice(2), {
-    default: {
-      sources: [
-        `./docassemble/*/data/sources`,  // In GitHub folder
-        `/usr/share/docassemble/files/playgroundsources/${id}/${project}/*.feature`, // From playground without S3
-        `/tmp/playgroundsources/${id}/${project}/*.feature` // From playground with S3
-      ],
-    }
-  });
-
-  // ========== Ends TODO: Abstract
   
   const { runConfiguration } = await cucumber_api.loadConfiguration({
     provided: build_config( argv ),
@@ -133,9 +105,9 @@ async function main() {
 
   /** Write to files.
    *
-   * Note: Don't add to the purely report-focused files. Those are files where
-   *    authors can focus on the info we give them, which they often miss in
-   *    the GitHub action.
+   * Note: Avoid adding to the purely report-focused files. Those are files
+   *    where authors can focus on the info we give them, which they often miss
+   *    in the GitHub action.
    */
 
   if ( success ) {
@@ -153,29 +125,12 @@ async function main() {
   const exitCode = success ? 0 : 50;
   process.exitCode = exitCode;
 
-  /** TODO:
-   * randomly generated test file cleanup
-   * 1. Generate files into the sources folder
-   * 2. copy the randomly generated files into the artifacts folder
-   * 3. MVP: delete the randomly generated files from the sources folder
-   * 4. post MVP: let the author keep the randomly generated tests in the
-   *    sources folder and make a PR with them
-   * */
-
-  /**
-   * Loop through sources folders
-   *   If there are generated files in the generated files folder(s)
-   *     delete that folder from the sources folders where we found them
-   * */
-
-  // This is hardcoded information from `provide_config` above.
-  // This code isn't used for anything other than detecting and removing color codes.
   let summary_file_name = SUMMARY_FILENAME;
   fs.readFile(summary_file_name, 'utf8', (read_error, text) => {
     if ( read_error ) {
       // Something else will probably show an error that's more relevant
       log.warn({ code: `ALK0056`, context: `post_run error`, },
-        `Failed to read cucumber report`, read_error
+        `Failed to read the report of the 3rd party library, cucumberjs. There may be more information above or below.`, read_error
       );
       return;
     }
@@ -210,7 +165,13 @@ async function main() {
         try {
           fs.readFileSync(`${ log.path }/${ log.unexpected_filename }`);  // Does it have contents?
           fs.appendFileSync(`${ log.path }/${ log.unexpected_filename }`, `\n\n\n\n\n` );
-        } catch ( ignore_err ) { /* Missing unexpected file is ok */ }
+        } catch ( ignore_err ) {
+          /* Missing "unexpected results" file is ok */
+        }
+
+        // TODO: Is this meant to write to the debug file or is this debug info
+        // really supposed to be in the "unexpected results" file? Or are these
+        // comments old?
 
         // Add the heading for debug content
         fs.appendFileSync( `${ log.path }/${ log.unexpected_filename }`,
@@ -224,7 +185,7 @@ async function main() {
 
     } catch ( writing_cucumber_error ) {
       let code = `ALK0182`;
-      let context = `post_run error`
+      let context = `post_run`
       let msg = `Something probably went wrong earlier. See warnings and errors above. Skipped writing to ${ log.path }/${ log.debug_log_filename }.`;
       try {
         log.warn({ code, context, }, msg, writing_cucumber_error );