@suffolklitlab/alkiln 5.13.2 → 5.13.3-feat-random-2

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

@@ -0,0 +1,541 @@
+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.+))/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();
+
+  // 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 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/example_of_chai_test_lifecycle.js

@@ -0,0 +1,78 @@
+const chai = require(`chai`);
+
+describe('chaijs before hooks', function () {
+  console.log(1);
+  before(() => console.log('--top-level before()'));
+  console.log(2);
+  beforeEach(() => console.log('--top-level beforeEach()'));
+  console.log(3);
+  describe('nesting 1', function () {
+    console.log(4);
+    before(() => console.log('--1. nested before()'));
+    console.log(5);
+    beforeEach(() => console.log('--1. nested beforeEach()'));
+    console.log(6);
+    it('is 1st nested spec', () => { console.log(7); return true; });
+    console.log(8);
+    it('is 2nd nested spec', () => { console.log(9); return true; });
+    console.log(10);
+  });
+  console.log(11);
+  describe('nesting 2', function () {
+    console.log(12);
+    before(() => console.log('--2. nested before()'));
+    console.log(13);
+    beforeEach(() => console.log('--2. nested beforeEach()'));
+    console.log(14);
+    it('is 1st nested spec', () => { console.log(15); return true; });
+    console.log(16);
+    it('is 2nd nested spec', () => { console.log(17); return true; });
+    console.log(18);
+  });
+  console.log(19);
+});
+
+/** Result:
+1
+2
+3
+4
+5
+6
+8
+10
+11
+12
+13
+14
+16
+18
+19
+
+
+  chaijs before hooks
+--top-level before()
+    nesting 1
+--1. nested before()
+--top-level beforeEach()
+--1. nested beforeEach()
+7
+      ✓ is 1st nested spec
+--top-level beforeEach()
+--1. nested beforeEach()
+9
+      ✓ is 2nd nested spec
+    nesting 2
+--2. nested before()
+--top-level beforeEach()
+--2. nested beforeEach()
+15
+      ✓ is 1st nested spec
+--top-level beforeEach()
+--2. nested beforeEach()
+17
+      ✓ is 2nd nested spec
+
+
+  4 passing (6ms)
+ * */

package/tests/unit_tests/getAllFields.test.js

@@ -7,6 +7,11 @@ chai.use(deepEqualInAnyOrder);
 const html = require('./html.fixtures.js');
 const fields = require('./fields.fixtures.js');
 const scope = require('../../lib/scope.js');
+
+const Log = require(`../../lib/utils/Log.js`);
+const log = new Log({ path: `_alkiln-misc_artifacts/all_fields_${ Date.now() }`, context: `unit_tests getAllFields` });
+scope.set_log({ log_obj: log });
+
 const getAllFields = scope.getAllFields;
 
 chai.config.truncateThreshold = 0

package/tests/unit_tests/getMatchingRows.test.js

@@ -6,6 +6,11 @@ const tables = require('./tables.fixtures.js');
 const fields = require('./fields.fixtures.js');
 const matches = require('./matches.fixtures.js');
 const scope = require('../../lib/scope.js');
+
+const Log = require(`../../lib/utils/Log.js`);
+const log = new Log({ path: `_alkiln-misc_artifacts/matching_rows_${ Date.now() }`, context: `unit_tests getMatchingRows` });
+scope.set_log({ log_obj: log });
+
 const getMatchingRows = scope.getMatchingRows;
 // Match state var instantiated in steps.js. TODO: Add tests for such rows.
 scope.row_needs_trigger_flag = `ALKiln: no trigger variable needed`;