@suffolklitlab/alkiln 5.13.4 → 5.15.0

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 );
+      });
+
+    });
+
+  });
+
+});