@suffolklitlab/alkiln 5.14.0 → 5.15.0

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

@@ -0,0 +1,563 @@
+const chai = require(`chai`);
+const expect = chai.expect;
+
+/**
+ * Discuss:
+ * - Test making more than one file?
+ * - Test deleting the files from the sources folder?
+ * - Test having multiple sources folders? (overdue)
+ * - Allow single quotes?
+ * */
+
+const TestGenerator = require(`../../../lib/setup/TestGenerator.js`);
+const Log = require(`../../../lib/utils/Log.js`);
+const fixtures = require(`./valid.fixtures.js`);
+const get_Gherkin_AST = require(`../../../lib/setup/get_Gherkin_AST`);
+
+
+const RANDOM_TABLE_PLACEHOLDER = fixtures.RANDOM_TABLE_PLACEHOLDER;
+const TABLE_ROW_REGEX = /^(?!(?:.*\| var \| value \|))(.*\| .* \|)/gm;
+const TABLE_PLACEHOLDER_REGEX = new RegExp(`(${ RANDOM_TABLE_PLACEHOLDER }(\n)?)+`, `g`);
+
+const WARNING_PLACEHOLDER = fixtures.WARNING_PLACEHOLDER;
+const WARNING_MSG_REGEX = /(ALK\d{4} )(.*\d{4}-\d\d-\d\d \d\d:\d\d:\d\dUTC.*(?!\n    ―)(?:\n)?.+)/g;
+
+const FLUB_PLACEHOLDER = fixtures.FLUB_PLACEHOLDER;
+const FLUB_REGEX = fixtures.FLUB_OPTIONS_REGEX;
+function comparable_text( text ) {
+  /** Replaces unimportant dynamic strings with placeholder strings
+   *
+   * We need to check that the contents of the file match the expected contents,
+   *    but the table contains random values, so we need to discount the table.
+   *    Same for warning timestamps and message text.
+   * */
+  let with_placeholders = text.replaceAll(
+    TABLE_ROW_REGEX,
+    RANDOM_TABLE_PLACEHOLDER
+  );
+  // Collapse multiple consecutive placeholders into one placeholder
+  let with_reduced_placeholders = with_placeholders.replaceAll(
+    TABLE_PLACEHOLDER_REGEX,
+    `${ RANDOM_TABLE_PLACEHOLDER }$2`
+  );
+
+  let without_warnings = with_reduced_placeholders.replace(
+    WARNING_MSG_REGEX, `$1${ WARNING_PLACEHOLDER }`
+  );
+
+  let without_random_flub_words = without_warnings.replaceAll(
+    FLUB_REGEX, FLUB_PLACEHOLDER
+  );
+
+  return without_random_flub_words;
+};
+
+
+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: `valid generators unit tests` });
+let fixture = null;
+let new_contents = null;
+let errors = null;
+let actual = null;
+let comparable = null;
+let num_Scenarios = null;
+let text_matches = null;
+function mutate_globals_with({ testing_vals, do_compare=false }) {
+  /** 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();
+
+  process.env.ALKILN_MAX_RANDOM_TESTS_PER_SCENARIO = 40;
+  if ( testing_vals.max_num_allowed ) {
+    process.env.ALKILN_MAX_RANDOM_TESTS_PER_SCENARIO = testing_vals.max_num_allowed;
+  }
+
+  // Fresh namespace
+  let generator = new TestGenerator();
+  // Mutates `fixture`
+  fixture = testing_vals;
+
+  let generators = fixture.arg;
+  if ( !Array.isArray( generators )) {
+    generators = [ fixture.arg ];
+  }
+
+  // Mutates `errors` and `num_Scenarios`
+  errors = [];
+  num_Scenarios = 0;
+  let new_files = [];
+  for ( let generator_text of generators ) {
+
+    let { new_contents: new_file, errors: new_errors } = generator.parse_file({
+      file_text: generator_text,
+      generator_path: `used_in_warning_logs`,
+      logger
+    });
+
+    new_files.push( new_file );
+    errors.push( ...new_errors );
+
+    // Validate new file. Should always be valid
+    let { AST: doc_AST, errors: file_errs } = get_Gherkin_AST({
+      file_text: new_file
+    });
+
+    let scenarios = doc_AST.feature.children;
+    num_Scenarios += scenarios.length;
+
+  }
+
+  // Mutates `new_contents`
+  new_contents = new_files.join(`\n\n`);
+
+  if ( do_compare ) {
+    // Mutates `comparable`
+    comparable = comparable_text( new_contents );
+    // Mutates `text_matches`
+    text_matches = comparable === fixture.expected;
+  }
+};
+
+
+describe(`Constrained random answers parser, when given a valid generator Scenario`, function () {
+
+  describe(`that is simple and normal`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.simple }); });
+
+    let outer = fixtures.simple;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`generates 2 Scenarios`, function() {
+      expect( num_Scenarios ).to.equal( fixture.num_Scenarios, `Wrong # of Scenarios: ${ num_Scenarios }/${ fixture.num_Scenarios }` );
+    });
+
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+
+  });
+
+  describe(`that has "constrain" and "generat" minimal Steps text`, function() {
+    before(function () { mutate_globals_with({ testing_vals: fixtures.generat }); });
+
+    let outer = fixtures.generat;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`that has "constrain" and "rand" minimal Steps text`, function() {
+    before(function () { mutate_globals_with({ testing_vals: fixtures.rand }); });
+
+    let outer = fixtures.rand;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`that has "constrain" and "make" minimal Steps text`, function() {
+    before(function () { mutate_globals_with({ testing_vals: fixtures.make }); });
+
+    let outer = fixtures.make;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`that has "constrain" and "made" minimal Steps text`, function() {
+    before(function () { mutate_globals_with({ testing_vals: fixtures.made }); });
+
+    let outer = fixtures.made;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`that has various complexities with 1 generator asking for 2 tests,`, function () {
+
+    before(function () { mutate_globals_with({
+      testing_vals: fixtures.complex, do_compare: true
+    }); });
+
+    let outer = fixtures.complex;
+    it(`includes these log codes: ${ JSON.stringify( outer.included_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.include.members( fixture.included_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`generates 2 Scenarios (skipping the extra appearance of "Scenario:")`, function() {
+      expect( num_Scenarios ).to.equal( fixture.num_Scenarios, `Wrong # of Scenarios: ${ num_Scenarios }/${ fixture.num_Scenarios }` );
+    });
+
+    it(`retains the text after the Feature, retains the comments before the table, retains the comments after the table, retains the Step after the table, retains and ignores a commented extraneous generator Step, keeps the comments in the table, has an extra line on the end`, function () {
+      expect( comparable ).to.equal( fixture.expected );
+    });
+
+  });
+
+  describe(`with an author's weird tag spacing`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.tags }); });
+
+    let outer = fixtures.tags;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`keeps those tags`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with author's tags on line 2`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.weird_spacing.tags_line_2 }); });
+
+    let outer = fixtures.weird_spacing.tags_line_2;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`keeps those tags and spacing`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with weird spacing in author's tags`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.weird_spacing.tags }); });
+
+    let outer = fixtures.weird_spacing.tags;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`keeps that spacing`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with weird indentations`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.weird_spacing.indents }); });
+
+    let outer = fixtures.weird_spacing.indents;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`keeps those indentation levels`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with no spacing in choices`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.weird_spacing.choices }); });
+
+    let outer = fixtures.weird_spacing.choices;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`gets a choice correctly`, function () {
+      expect( new_contents ).to.match( fixture.find_1 );
+    });
+  });
+
+  describe(`with 3 columns`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.columns_3 }); });
+
+    let outer = fixtures.columns_3;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`adds a "trigger" column with those values`, function () {
+      expect( new_contents ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with 4 columns`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.columns_4 }); });
+
+    let outer = fixtures.columns_4;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`ignores the 4th column`, function () {
+      expect( new_contents ).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with comments before and in the table`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.rows_comments }); });
+
+    let outer = fixtures.rows_comments;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`removes the comments`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with a comment after the table`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.comment_after_last_row }); });
+
+    let outer = fixtures.comment_after_last_row;
+    it(`has these exact log codes: ${ JSON.stringify( outer.included_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.include.members( fixture.included_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`keeps and repeats the comment`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with empty rows before and in the table`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.rows_empty }); });
+
+    let outer = fixtures.rows_empty;
+    it(`has these exact log codes: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`removes the empty rows`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with no number value`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.no_number }); });
+
+    let outer = fixtures.warnings.no_number;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`generates 1 test`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with too many number values in one Step`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.multiple_numbers }); });
+
+    let outer = fixtures.warnings.multiple_numbers;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`uses the last number given`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with too many "number" Steps in one Scenario`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.multiple_number_Steps }); });
+
+    let outer = fixtures.warnings.multiple_number_Steps;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`uses the last Step given`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`with 2 "number" Steps in one Scenario and both have multiple numbers`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.multiple_number_Steps_and_numbers }); });
+
+    let outer = fixtures.warnings.multiple_number_Steps_and_numbers;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`uses the last Step and number given`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+  });
+
+  describe(`that asks for 3 tests when only 2 unique tests are possible`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.fewer_unique_than_requested }); });
+
+    let outer = fixtures.warnings.fewer_unique_than_requested;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.included_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.include.members( fixture.included_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`returns the right text`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+
+    it(`only makes 2 tests`, function () {
+      expect( num_Scenarios ).to.equal( fixture.num_Scenarios, `Wrong # of Scenarios: ${ num_Scenarios }/${ fixture.num_Scenarios }` );
+    });
+    
+    it(`the 2 tests are unique`, function () {
+      for ( let to_find_1_of of fixture.find_1_of ) {
+        let text_regex = new RegExp( to_find_1_of, `g` );
+          let matches = new_contents.match( text_regex );
+          expect( matches ).to.be.an(`array`);
+          expect( matches.length ).to.equal( 1 );
+      }
+    });
+
+    it(`tries at least 10 times`, function(){
+      let codes = get_log_codes({ logger });
+      // I'm curious about what the big O value of this methodology is
+      // Other methods: https://stackoverflow.com/questions/5667888/counting-the-occurrences-frequency-of-array-elements
+      let codes_regex = new RegExp( fixture.repeat.code, `g` );
+      let codes_str = codes.join(`;`);
+      let code_matches = codes_str.match( codes_regex );
+      expect( code_matches ).to.be.an(`array`);
+      expect( code_matches.length ).to.be.above( fixture.repeat.count - 1 );
+    });
+  });
+
+  describe(`that asks for over max # of tests allowed - 1 -`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.warnings.over_max }); });
+
+    let outer = fixtures.warnings.over_max;
+    it(`has these exact log codes with warnings: ${ JSON.stringify( outer.exact_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.have.all.members( fixture.exact_log_codes );
+    });
+    
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`has max # of tests - 1`, function () {
+      expect( comparable_text( new_contents )).to.equal( fixture.expected );
+    });
+
+  });
+
+  describe(`that has a blank var value in a generator column`, function () {
+
+    before(function () { mutate_globals_with({ testing_vals: fixtures.empty_string_value }); });
+
+    let outer = fixtures.empty_string_value;
+    it(`includes at least one of all these log codes with warnings: ${ JSON.stringify( outer.included_log_codes )}`, function () {
+      expect( get_log_codes({ logger }) ).to.include.members( fixture.included_log_codes );
+    });
+
+    it(`returns no errors`, function () { expect( errors ).to.have.lengthOf( 0 ); });
+
+    it(`has the right non-random text`, function () {
+      expect( comparable_text( new_contents ) ).to.equal( fixture.expected );
+    });
+
+    it(`makes 2 tests`, function () {
+      expect( num_Scenarios ).to.equal( fixture.num_Scenarios, `Wrong # of Scenarios: ${ num_Scenarios }/${ fixture.num_Scenarios }` );
+    });
+
+    describe(`the "" value does get its own Scenario`, function () {
+
+      for ( let to_find_1_of of outer.find_1_of ) {
+        let text_regex = new RegExp( to_find_1_of, `g` );
+        it(`for the var value "${ to_find_1_of }"`, function () {
+          let matches = new_contents.match( text_regex );
+          expect( matches, `Unable to find column matching ${ to_find_1_of }` ).to.be.an(`array`);
+          expect( matches.length ).to.equal( 1 );
+        })
+      }
+      
+    });
+  });
+
+});

package/tests/unit_tests/log.test.js

@@ -169,6 +169,10 @@ describe(`An instance of log`, function () {
   })
 
   describe(`given totally custom metadata`, function () {
+    let error;
+    before(function() {
+      error = new Error(`custom_SUCCESS_error`);
+    });
     it(`.success overwrites the right values`, async function() {
       let options = {
         before: `custom_SUCCESS_before~`,
@@ -176,17 +180,22 @@ describe(`An instance of log`, function () {
         icon: `custom_SUCCESS_icon`,
         code: `custom_SUCCESS_code`,
         context: `custom_SUCCESS_context`,
+        // Discuss: too complex to test right now? Test separately? Test
+        //     unexpected file contents?
+        error,
         do_throw: true,
       };
       let returned = log.success( options, `custom_SUCCESS_log` );
       // Note the intentional lack of space with `before`
       expect( returned ).to.include(`custom_SUCCESS_before~🌈 custom_SUCCESS_code custom_SUCCESS_context SUCCESS`);
       expect( returned ).to.include(`custom_SUCCESS_log`);
+      expect( returned ).to.include( error.stack );
       expect( returned ).to.not.include(`Skip`);
     });
     it(`.success stores the right text in the debug file`, async function() {
       expect_debug_file_to_include(`custom_SUCCESS_before~🌈 custom_SUCCESS_code custom_SUCCESS_context SUCCESS`);
       expect_debug_file_to_include(`custom_SUCCESS_log`);
+      expect_debug_file_to_include( error.stack );
       expect_debug_file_to_not_include(`Skip`);
     });
   })
@@ -313,10 +322,10 @@ describe(`An instance of log`, function () {
       } catch ( error ) {
         error_to_test = error;
       }
-      // Note: No metadata is included in the error so that we don't have
-      // to re-throw every error that comes in and they can keep their nice
-      // stack traces.
-      // Note: Also excludes logs from error message
+      // Note: No metadata is included in the error so that we don't have to
+      // re-throw every error that comes in (in order to add the metadata) and
+      // they can keep their nice stack traces. Note: Also excludes logs from
+      // error message
       expect( error_to_test.message ).to.include(`CUSTOM_THROW_ERROR_STRING`);
       expect( error_to_test.stack ).to.include(`at Log.throw`);
       expect( error_to_test.stack ).to.not.include(`Skip`);
@@ -435,47 +444,14 @@ describe(`An instance of log`, function () {
   })
 
   describe(`with a value for \`error\` and no throw with .debug()`, function () {
-    it(`returns a value that excludes the error and the error stack`, async function() {
+    it(`returns a value that includes the error and the error stack, but does not throw`, async function() {
       let options = { error: `custom_DEBUG_non_thrown_error`, };
       let returned = log.debug( options );
-      expect( returned ).to.not.include(`custom_DEBUG_non_thrown_error`);
+      expect( returned ).to.include(`custom_DEBUG_non_thrown_error`);
       expect( returned ).to.not.include(`at Log.throw`);
     });
-    it(`excludes the error in the debug file`, async function() {
-      expect_debug_file_to_not_include(`custom_DEBUG_non_thrown_error`);
-    });
-    it(`stores the warning code in the debug file`, async function() {
-      expect_debug_file_to_include(`ALK0223`);
-    });
-    it(`stores the text 'Skip' in the debug file`, async function() {
-      expect_debug_file_to_include(`Skip`);
-    });
-    it(`excludes the error in the unexpected output file`, async function() {
-      expect_unexpected_output_file_to_not_include(`custom_DEBUG_non_thrown_error`);
-    });
-    it(`stores the warning code in the unexpected output file`, async function() {
-      expect_unexpected_output_file_to_include(`ALK0223`);
-    });
-    it(`stores the text 'Skip' in the unexpected output file`, async function() {
-      expect_unexpected_output_file_to_include(`Skip`);
-    });
-  })
-
-  describe(`given an error without a do_throw`, function () {
-    it(`.debug saves a warning and ignores the error`, async function() {
-      let options = {
-        error: `Illegal error`,
-        do_throw: false,
-      };
-      let returned = log.debug( options, `DEBUG log with illegal error` );
-      expect( returned ).to.include(`DEBUG log with illegal error`);
-      expect( returned ).to.not.include(`Illegal error`);
-      // To not include `Illegal error`
-    });
-    it(`.debug stores and excludes the right text in the debug file`, async function() {
-      expect_debug_file_to_include(`ALK0223`);
-      expect_debug_file_to_include(`DEBUG log with illegal error`);
-      expect_debug_file_to_not_include(`Illegal error`);
+    it(`includes the error in the debug file`, async function() {
+      expect_debug_file_to_include(`custom_DEBUG_non_thrown_error`);
     });
   })