@suffolklitlab/alkiln 5.14.0 → 5.15.0-deps-2

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@suffolklitlab/alkiln",
-  "version": "5.14.0",
+  "version": "5.15.0-deps-2",
   "description": "Integrated automated end-to-end testing with docassemble, puppeteer, and cucumber.",
   "main": "lib/index.js",
   "scripts": {
     "test": "npm run unit && npm run codes && npm run cucumber",
-    "cucumber": "./lib/run_cucumber.js",
     "local": "npm run setup && npm run cucumber; npm run takedown",
-    "pass": "npm run cucumber 'not @error and not @temp_error'",
-    "fail": "npm run cucumber '@error'",
-    "setup": "./lib/docassemble/setup.js",
     "takedown": "./lib/docassemble/takedown.js",
+    "setup": "./lib/docassemble/setup.js",
     "server_install": "./lib/docassemble/server_install.js",
-    "unit": "mocha tests/unit_tests/*.test.*",
+    "pass": "npm run cucumber 'not @error and not @temp_error'",
+    "fail": "npm run cucumber '@error'",
+    "cucumber": "npm run build && ./lib/run_cucumber.js",
+    "build": "npm run artifacts && npm run validate && npm run generate",
+    "validate": "./lib/setup/validate.js",
+    "generate": "./lib/setup/generate.js",
+    "artifacts": "./lib/setup/artifacts.js",
+    "unit": "npm run artifacts && mocha --recursive 'tests/unit_tests/**/*.test.*'",
     "codes": "tests/log_codes/check_codes.sh ."
   },
   "repository": {
@@ -37,7 +41,7 @@
     "@axe-core/puppeteer": "4.7.3",
     "@cucumber/cucumber": "9.3.0",
     "@faker-js/faker": "7.3.0",
-    "axios": "1.7.3",
+    "axios": "1.9.0",
     "chai": "4.2.0",
     "cheerio": "1.0.0-rc.10",
     "deep-equal-in-any-order": "2.0.0",
@@ -46,8 +50,8 @@
     "fast-glob": "3.2.12",
     "minimatch": "3.0.5",
     "minimist": "1.2.8",
-    "mocha": "9.2.2",
-    "pdfjs-dist": "3.11.174",
+    "mocha": "11.5.0",
+    "pdfjs-dist": "5.2.133",
     "puppeteer": "22.15.0",
     "qs": "6.10.3",
     "sanitize-filename": "1.6.3",
@@ -57,6 +61,9 @@
     "alkiln-server-install": "./lib/docassemble/server_install.js",
     "alkiln-setup": "./lib/docassemble/setup.js",
     "alkiln-takedown": "./lib/docassemble/takedown.js",
-    "alkiln-run": "./lib/run_cucumber.js"
+    "alkiln-run": "./lib/run_cucumber.js",
+    "alkiln-artifacts": "./lib/setup/artifacts.js",
+    "alkiln-validate": "./lib/setup/validate.js",
+    "alkiln-generate": "./lib/setup/generate.js"
   }
 }

package/tests/log_codes/check_codes.sh

@@ -11,12 +11,13 @@ exit_code=0
 
 echo " -------------------------------------------------------
 | Usage:                                                |
-| bash $(basename $0) [dir] [c file] [c folder] [-l arg]
+| bash $(basename $0) [dir] [c file] [c folder]         |
 | dir:      The directory in which to search for logs   |
 | c file:   Name of the log instance counter file       |
 | c folder: Path to the folder of the log counter file  |
-| -l arg:   \"1\" prints extra logs                       |
  -------------------------------------------------------"
+# | bash $(basename $0) [dir] [c file] [c folder] [-l arg]
+# | -l arg:   \"1\" prints extra logs                       |
 
 # Get flags and their values
 loudness="0"
@@ -56,7 +57,7 @@ fi
 # removed and are no longer used. Syntax used works with GitHub cli - [[:digit:]]
 # https://stackoverflow.com/a/6901221
 # Exclude files and paths
-instances=$(find "$where_to_look" -type f ! -name "CONTRIBUTING.md" ! -name "$expected_instances_file" ! -name "debug_log.txt" ! -name "cucumber-report.txt" ! -path "*/tests/*" ! -path "*/node_modules/*" ! -path "*/ALKilnTests/*" ! -path "*/alkiln-*/*" ! -path "*/_alkiln*/*" ! -path "*/docs/decisions/*" ! -path "*/\.*" -print0 | xargs -0 -P 4 grep -0 -ro 'ALK[[:digit:]][[:digit:]][[:digit:]][[:digit:]]' | grep -v -- '--' )
+instances=$(find "$where_to_look" -type f ! -name "CONTRIBUTING.md" ! -name "$expected_instances_file" ! -name "debug_log.txt" ! -name "cucumber-report.txt" ! -name "_alkiln*" ! -path "*/tests/*" ! -path "*/node_modules/*" ! -path "*/ALKilnTests/*" ! -path "*/alkiln-*/*" ! -path "*/_alkiln*/*" ! -path "*/docs/*" ! -path "*/\.*" -print0 | xargs -0 -P 4 grep -0 -ro 'ALK[[:digit:]][[:digit:]][[:digit:]][[:digit:]]' | grep -v -- '--' )
 
 if [[ "$loudness" != "0" ]]; then
   total_instances=$(echo "$instances" | wc -l)
@@ -101,7 +102,7 @@ fi
 indx=0
 too_many=()
 missing=()
-while [ "$indx" -lt "$highest_code" ]; do
+while [ "$indx" -le "$highest_code" ]; do
   # Turn the index into a log code by prepending ALK and adding leading zeros
   log_code=$(printf "ALK%04d" "$indx")
   # Count ";" - a stand-in for the number of
@@ -126,24 +127,27 @@ while [ "$indx" -lt "$highest_code" ]; do
   # To add to the list of strings to print later
   short_msg="$log_code $num_paths/$num_expected"
   long_msg="$log_code act/exp "
-  long_msg+="$num_paths/$num_expected:"
+  long_msg+="$num_paths/$num_expected"
+  if [ "$num_paths" -gt "$num_expected" ]; then
+    long_msg+=":"
+  fi
   long_msg+=$(echo "${codes_unique_paths[$indx]}" | sed 's/;/\n  - /g')
 
   # missing
   if [ "$num_paths" -lt "$num_expected" ]; then
-    if [[ "$loudness" != "0" ]]; then
+    # if [[ "$loudness" != "0" ]]; then
       missing+=("$long_msg")
-    else
-      missing+=("$short_msg")
-    fi
+    # else
+    #   missing+=("$short_msg")
+    # fi
 
   # too_many
   elif [ "$num_paths" -gt "$num_expected" ]; then
-    if [[ "$loudness" != "0" ]]; then
+    # if [[ "$loudness" != "0" ]]; then
       too_many+=("$long_msg")
-    else
-      too_many+=("$short_msg")
-    fi
+    # else
+    #   too_many+=("$short_msg")
+    # fi
   fi
 
   let indx++

package/tests/log_codes/log_code_expected_instances.txt

@@ -5,8 +5,11 @@ Why we need duplicate codes sometimes: GitHub actions sometimes don't have ways
 The script that tests the log codes will ignore this file (or any file with this name), and any file with these names: check_codes.sh, debug_log.txt, cucumber-report.txt. It will also ignore files in folders with these names:, node_modules, ALKilnTests, alkiln-*, _alkiln*. That list might get updated, so for an up-to-date list, always check the file check_codes.sh where we use `--exclude=` and such.
 
 Reasons for deletion:
+0000 - unknown
 0053 - duplicate log
 0173 - redundant
+0181 - unknown
+0223 - changed Log behavior ("Only logs that throw should give a value to `error`.")
 
 ALK0000:0
 ALK0001:1
@@ -231,3 +234,58 @@ ALK0219:1
 ALK0220:1
 ALK0221:1
 ALK0222:1
+ALK0223:0
+ALK0224:1
+ALK0225:1
+ALK0226:1
+ALK0227:1
+ALK0228:1
+ALK0229:1
+ALK0230:1
+ALK0231:1
+ALK0232:1
+ALK0233:1
+ALK0234:1
+ALK0235:1
+ALK0236:1
+ALK0237:1
+ALK0238:1
+ALK0239:1
+ALK0240:1
+ALK0241:1
+ALK0242:1
+ALK0243:1
+ALK0244:1
+ALK0245:1
+ALK0246:1
+ALK0247:1
+ALK0248:1
+ALK0249:1
+ALK0250:1
+ALK0251:1
+ALK0252:1
+ALK0253:1
+ALK0254:1
+ALK0255:1
+ALK0256:1
+ALK0257:1
+ALK0258:1
+ALK0259:1
+ALK0260:1
+ALK0261:1
+ALK0262:1
+ALK0263:1
+ALK0264:1
+ALK0265:1
+ALK0266:1
+ALK0267:1
+ALK0268:1
+ALK0269:1
+ALK0270:1
+ALK0271:1
+ALK0272:1
+ALK0273:1
+ALK0274:1
+ALK0275:1
+ALK0276:1
+ALK0277:1

package/tests/unit_tests/constrained_random_answers/invalid.fixtures.js

@@ -0,0 +1,178 @@
+/** Actual and expected values for INvalid constrained random answer tests. */
+
+module.exports = fixts = {};
+
+/** Research notes
+ * 
+ * Valid: A feature is valid without a description
+ * Valid: A scenario is valid without a description
+ * 
+ * TODO
+ * Research: Can we get back null or undefined without syntax errors? (unlikely)
+ * Research: Can a feature.children item exist without having a `.scenario`
+ *     prop? (unlikely)
+ * */
+
+fixts.generator_missing_Feature = {};
+fixts.generator_missing_Feature.arg = `Scenario: Invalid feature file`;
+fixts.generator_missing_Feature.expected = null;
+fixts.generator_missing_Feature.error_codes = [ `ALK0232` ];
+fixts.generator_missing_Feature.log_codes = [ `ALK0232` ];
+
+fixts.generator_missing_contents = {};
+fixts.generator_missing_contents.arg = ``;
+fixts.generator_missing_contents.expected = null;
+fixts.generator_missing_contents.error_codes = [ `ALK0233` ];
+fixts.generator_missing_contents.log_codes = [ `ALK0233` ];
+
+fixts.generator_0_Scenarios = {};
+fixts.generator_0_Scenarios.arg = `Feature: No scenarios`;
+fixts.generator_0_Scenarios.expected = null;
+fixts.generator_0_Scenarios.error_codes = [ `ALK0235` ];
+fixts.generator_0_Scenarios.log_codes = [ `ALK0235` ];
+
+
+/**
+ * Missing fore_Step keywords
+ * Missing constraints Step keywords
+ * */
+
+fixts.missing_fore_Step_keywords = {};
+fixts.missing_fore_Step_keywords.arg =
+`Feature: I generate constrained random tests
+
+Scenario: I fail with missing keywords for a fore Step
+  Given ALKiln makes 2
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_kickout"
+  And ALKiln tests get to "end" with:
+    | var | possible_values |
+    | user_choice | correct;; wrong |
+`;
+fixts.missing_fore_Step_keywords.expected = null;
+fixts.missing_fore_Step_keywords.error_codes = [ `ALK0242`, `ALK0263` ];
+fixts.missing_fore_Step_keywords.log_codes = [
+  `ALK0237`,
+  `ALK0242`,
+  `ALK0263`,
+];
+
+
+fixts.missing_constraints_Step_keywords = {};
+fixts.missing_constraints_Step_keywords.arg =
+`Feature: I generate constrained random tests
+
+Scenario: I fail with missing keywords for a constraints Step
+  Given ALKiln makes 2 constrained random answers tests
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_kickout"
+  And tests get to "end" with:
+    | var | possible_values |
+    | user_choice | correct;; wrong |
+`;
+fixts.missing_constraints_Step_keywords.expected = null;
+fixts.missing_constraints_Step_keywords.error_codes = [ `ALK0256`, `ALK0263` ];
+fixts.missing_constraints_Step_keywords.log_codes = [
+  `ALK0237`, `ALK0243`, `ALK0244`,
+  `ALK0245`, `ALK0248`, `ALK0249`,
+  `ALK0256`,
+  `ALK0263`,
+];
+
+
+fixts.missing_table = {};
+fixts.missing_table.arg =
+`Feature: I generate constrained random tests
+
+Scenario: I fail with the first missing table
+  Given ALKiln makes 2 constrained random answers tests
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_kickout"
+  And ALKiln tests get to "end" with:
+  And ALKiln tests get to "end" with:
+`;
+// ======= ENDS ARG ======= //
+fixts.missing_table.expected = null;
+fixts.missing_table.error_codes = [ `ALK0251`, `ALK0263` ];
+fixts.missing_table.log_codes = [
+  `ALK0237`, `ALK0243`, `ALK0244`,
+  `ALK0245`, `ALK0248`, `ALK0249`, `ALK0246`,
+  `ALK0251`,
+  `ALK0263`,
+];
+
+
+fixts.missing_ids = {};
+fixts.missing_ids.arg =
+`Feature: I generate constrained random tests
+
+Scenario: I fail with missing quoted ids in constrained random answers
+  Given ALKiln makes 2 constrained random answers tests
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_kickout"
+  And ALKiln will get to end with:
+    | var | possible_values |
+    | user_choice | correct;; wrong |
+`;
+// ======= ENDS ARG ======= //
+fixts.missing_ids.expected = null;
+fixts.missing_ids.error_codes = [ `ALK0250`, `ALK0263` ];
+fixts.missing_ids.log_codes = [
+  `ALK0237`, `ALK0243`, `ALK0244`,
+  `ALK0245`, `ALK0248`, `ALK0249`, `ALK0246`,
+  `ALK0250`,
+  `ALK0263`,
+];
+
+
+// A valid generator Scenario, but an erroring test when run in cucumber, so it
+// will error here instead
+fixts.only_row_is_header = {};
+fixts.only_row_is_header.arg =
+`Feature: I generate constrained random tests
+
+Scenario: Non-table row after table header
+  Given ALKiln makes 2 constrained random answers tests
+  Given the final Scenario status should be "failed"
+  Given I start the interview at "test_kickout"
+  And ALKiln will get to "end" with:
+    | var | possible_values |
+    Then non-table line
+    | user_choice | correct;; wrong |
+`;
+fixts.only_row_is_header.expected = null;
+fixts.only_row_is_header.error_codes = [`ALK0252`, `ALK0263`];
+fixts.only_row_is_header.log_codes = [
+  `ALK0237`, `ALK0243`, `ALK0244`,
+  `ALK0245`, `ALK0248`, `ALK0249`, `ALK0246`,
+  `ALK0252`,
+  `ALK0263`,
+];
+
+/**
+ * No test for a table interrupted in the middle of regular rows (the parser
+ * can't detect it)
+ * */
+
+
+fixts.multiple_scenarios = {};
+fixts.multiple_scenarios.arg =
+`Feature: It is invalid to have multiple Scenarios in one generator file
+
+Scenario: The first of 2 Scenarios
+  Given ALKiln makes 1 constrained random answers tests
+  Given I start the interview at "test_kickout"
+  And ALKiln will get to "end" with:
+    | var | possible_values |
+    | user_choice | correct;; wrong |
+
+Scenario: The second of 2 Scenarios
+  Given ALKiln makes 1 constrained random answers tests
+  Given I start the interview at "test_kickout"
+  And ALKiln will get to "end" with:
+    | var | possible_values |
+    | user_choice | correct;; wrong |
+`;
+fixts.multiple_scenarios.expected = null;
+fixts.multiple_scenarios.error_codes = [`ALK0236`];
+fixts.multiple_scenarios.log_codes = [`ALK0236`];

package/tests/unit_tests/constrained_random_answers/invalid.test.js

@@ -0,0 +1,251 @@
+const chai = require(`chai`);
+const expect = chai.expect;
+
+const TestGenerator = require(`../../../lib/setup/TestGenerator.js`);
+const Log = require(`../../../lib/utils/Log.js`);
+const fixtures = require(`./invalid.fixtures.js`);
+
+
+function get_error_codes({ errors }) {
+  /** Returns a list of ALKiln ALK#### codes from Error stacks
+   * 
+   * @param {object} obj - Named arguments
+   * @param {[Error]} obj.errors - List of Error instances
+   * 
+   * @returns {[str]} - List of ALKiln log codes in the errors
+   * */
+  let codes = [];
+  for ( let error of errors ) {
+    let matches = error.stack.match(/ALK\d\d\d\d/gm);
+    if ( matches ) {
+      codes.push( ...matches );
+    }
+  }
+
+  return codes;
+};
+
+
+function get_log_codes({ logger }) {
+  /** Returns a list of ALKiln codes from arguments sent to a Log instance
+   * 
+   * @params {object} obj - Named arguments
+   * @params {Log} obj.logger - An instance of Log
+   * @params {object} obj.logger.opts - Options passed to the Log instance
+   * @params {str} obj.logger.opts.code - ALK#### formatted log code
+   * @params {[str]} obj.logger.logs - Additional messages to be logged
+   * 
+   * @returns {[str]} - List of ALKiln log codes in the collection of logs
+   * */
+  let codes = [];
+
+  for ( let record of logger.internal_log_records ) {
+    codes.push( record.opts.code );
+  }
+
+  return codes;
+}
+
+/** Variables that will change their values for each `it()` */
+const logger = new Log({ context: `invalid generators unit tests` });
+let fixture = null;
+let new_contents = null;
+let errors = null;
+let actual = null;
+function mutate_globals_with({ testing_vals }) {
+  /** Set up values for parsing, parse, record values. Mutates in-scope
+   *    variables in a way that helps chaijs (mocha really) get the right
+   *    values to the right places.
+   * 
+   * @params {object} testing_vals - Arguments to pass to the function and
+   *     expected values
+   * 
+   * @returns {undefined}
+   * */
+  // Reset log codes
+  logger.clear_internal_log_records();
+
+  // Fresh namespace
+  let generator = new TestGenerator();
+  // Mutates `fixture`
+  fixture = testing_vals;
+  // Mutates `new_contents` and `error`
+  ({ new_contents, errors } = generator.parse_file({
+    file_text: fixture.arg,
+    generator_path: `used_in_warning_logs`,
+    logger
+  }) );
+};
+
+describe(`Constrained random answers parser,`, function () {
+
+  describe(`when given a missing Feature keyword`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.generator_missing_Feature }); });
+    
+    let outer = fixtures.generator_missing_Feature;
+
+    it(`returns \`null\` for contents value`, function () {
+      expect( new_contents ).to.equal( fixture.expected );
+    });
+    it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+      expect( get_error_codes({ errors: errors }) )
+                .to.have.all.members( fixture.error_codes );
+    });
+    it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+    });
+
+  });
+
+  describe(`when given an empty string`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.generator_missing_contents }); });
+    
+    let outer = fixtures.generator_missing_contents;
+
+    it(`returns \`null\` for contents value`, function () {
+      expect( new_contents ).to.equal( fixture.expected );
+    });
+    it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+      expect( get_error_codes({ errors: errors }) )
+                .to.have.all.members( fixture.error_codes );
+    });
+    it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+    });
+
+  });
+
+  describe(`when given generator text missing Scenarios`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.generator_0_Scenarios }); });
+    
+    let outer = fixtures.generator_0_Scenarios;
+
+    it(`returns \`null\` for contents value`, function () {
+      expect( new_contents ).to.equal( fixture.expected );
+    });
+    it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+      expect( get_error_codes({ errors: errors }) )
+                .to.have.all.members( fixture.error_codes );
+    });
+    it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+    });
+
+  });
+
+  describe(`when given an invalid generator Scenario`, function () {
+
+    describe(`where a num tests fore Step is missing keywords,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.missing_fore_Step_keywords }); });
+
+      let outer = fixtures.missing_fore_Step_keywords;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+    describe(`where a constraints Step is missing keywords,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.missing_constraints_Step_keywords }); });
+
+      let outer = fixtures.missing_constraints_Step_keywords;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+    describe(`that is missing a table,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.missing_table }); });
+
+      let outer = fixtures.missing_table;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+    describe(`that has no quoted ids,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.missing_ids }); });
+
+      let outer = fixtures.missing_ids;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+    describe(`that has no header row,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.only_row_is_header }); });
+
+      let outer = fixtures.only_row_is_header;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+    describe(`that has multiple Scenarios,`, function () {
+
+      before(function () { mutate_globals_with({ testing_vals: fixtures.multiple_scenarios }); });
+
+      let outer = fixtures.multiple_scenarios;
+      
+      it(`returns \`null\` for contents value`, function () {
+        expect( new_contents ).to.equal( fixture.expected );
+      });
+      it(`has these exact error codes: ${ JSON.stringify( outer.error_codes )}`, function () {
+        expect( get_error_codes({ errors: errors }) ).to.have.all.members( fixture.error_codes );
+      });
+      it(`has these exact _log_ codes: ${ JSON.stringify( outer.log_codes )}`, function () {
+        expect( get_log_codes({ logger }) ).to.have.all.members( fixture.log_codes );
+      });
+
+    });
+
+  });
+
+});