Merge pull request #335 from openactive/per-validation-mode-required-…

…and-recommended-rules Per validation mode required and recommended rules
openactive · Oct 25, 2019 · fe08fcf · fe08fcf
2 parents 3464a74 + f392eb0
commit fe08fcf
Show file tree

Hide file tree

Showing 7 changed files with 224 additions and 9 deletions.
diff --git a/src/classes/model.js b/src/classes/model.js
@@ -44,20 +44,51 @@ const Model = class {
     return this.data.commonTypos || {};
   }
 
-  get requiredFields() {
-    return this.data.requiredFields || [];
+  getImperativeConfiguration(validationMode) {
+    if (
+      typeof this.validationMode === 'object'
+      && typeof this.validationMode[validationMode] === 'string'
+    ) {
+      return this.imperativeConfiguration[this.validationMode[validationMode]];
+    }
+    return undefined;
+  }
+
+  getRequiredFields(validationMode) {
+    let fields;
+    const specificImperativeConfiguration = this.getImperativeConfiguration(validationMode);
+    if (typeof specificImperativeConfiguration === 'object') {
+      fields = specificImperativeConfiguration.requiredFields;
+    } else {
+      fields = this.data.requiredFields;
+    }
+    return fields || [];
   }
 
   hasRequiredField(field) {
     return PropertyHelper.arrayHasField(this.requiredFields, field, this.version);
   }
 
-  get requiredOptions() {
-    return this.data.requiredOptions || [];
+  getRequiredOptions(validationMode) {
+    let options;
+    const specificImperativeConfiguration = this.getImperativeConfiguration(validationMode);
+    if (typeof specificImperativeConfiguration === 'object') {
+      options = specificImperativeConfiguration.requiredOptions;
+    } else {
+      options = this.data.requiredOptions;
+    }
+    return options || [];
   }
 
-  get recommendedFields() {
-    return this.data.recommendedFields || [];
+  getRecommendedFields(validationMode) {
+    let fields;
+    const specificImperativeConfiguration = this.getImperativeConfiguration(validationMode);
+    if (typeof specificImperativeConfiguration === 'object') {
+      fields = specificImperativeConfiguration.recommendedFields;
+    } else {
+      fields = this.data.recommendedFields;
+    }
+    return fields || [];
   }
 
   hasRecommendedField(field) {
@@ -114,6 +145,14 @@ const Model = class {
     }
     return undefined;
   }
+
+  get validationMode() {
+    return this.data.validationMode;
+  }
+
+  get imperativeConfiguration() {
+    return this.data.imperativeConfiguration;
+  }
 };
 
 module.exports = Model;
diff --git a/src/rules/core/recommended-fields-rule-spec.js b/src/rules/core/recommended-fields-rule-spec.js
@@ -3,6 +3,8 @@ const Model = require('../../classes/model');
 const ModelNode = require('../../classes/model-node');
 const ValidationErrorType = require('../../errors/validation-error-type');
 const ValidationErrorSeverity = require('../../errors/validation-error-severity');
+const ValidationMode = require('../../helpers/validation-mode');
+const OptionsHelper = require('../../helpers/options');
 
 describe('RecommendedFieldsRule', () => {
   const model = new Model({
@@ -11,6 +13,16 @@ describe('RecommendedFieldsRule', () => {
       'description',
       'name',
     ],
+    validationMode: {
+      C1Request: 'request',
+    },
+    imperativeConfiguration: {
+      request: {
+        recommendedFields: [
+          'duration',
+        ],
+      },
+    },
   }, 'latest');
   model.hasSpecification = true;
 
@@ -90,6 +102,50 @@ describe('RecommendedFieldsRule', () => {
     }
   });
 
+  describe('when validation mode is on with separate required fields', () => {
+    const options = new OptionsHelper({ validationMode: ValidationMode.C1Request });
+
+    it('should return no errors if all required fields are present', () => {
+      const data = {
+        type: 'Event',
+        duration: 'PT1H30M',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(0);
+    });
+
+    it('should return a warning per field if any required fields are missing', () => {
+      const data = {
+        type: 'Event',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(1);
+
+      for (const error of errors) {
+        expect(error.type).toBe(ValidationErrorType.MISSING_RECOMMENDED_FIELD);
+        expect(error.severity).toBe(ValidationErrorSeverity.WARNING);
+      }
+    });
+  });
+
   describe('with inheritsTo properties', () => {
     it('should respect recommended fields when inheritsTo is *', () => {
       const modelObj = loadInheritanceModel();

diff --git a/src/rules/core/recommended-fields-rule.js b/src/rules/core/recommended-fields-rule.js
@@ -32,7 +32,8 @@ module.exports = class RecommendedFieldsRule extends Rule {
       return [];
     }
     const errors = [];
-    for (const field of node.model.recommendedFields) {
+
+    for (const field of node.model.getRecommendedFields(node.options.validationMode)) {
       const testValue = node.getValueWithInheritance(field);
       const example = node.model.getRenderedExample(field);
       if (typeof testValue === 'undefined') {

diff --git a/src/rules/core/required-fields-rule-spec.js b/src/rules/core/required-fields-rule-spec.js
@@ -3,6 +3,8 @@ const Model = require('../../classes/model');
 const ModelNode = require('../../classes/model-node');
 const ValidationErrorType = require('../../errors/validation-error-type');
 const ValidationErrorSeverity = require('../../errors/validation-error-severity');
+const ValidationMode = require('../../helpers/validation-mode');
+const OptionsHelper = require('../../helpers/options');
 
 describe('RequiredFieldsRule', () => {
   const model = new Model({
@@ -12,6 +14,16 @@ describe('RequiredFieldsRule', () => {
       'activity',
       'location',
     ],
+    validationMode: {
+      C1Request: 'request',
+    },
+    imperativeConfiguration: {
+      request: {
+        requiredFields: [
+          'duration',
+        ],
+      },
+    },
   }, 'latest');
   model.hasSpecification = true;
 
@@ -115,6 +127,50 @@ describe('RequiredFieldsRule', () => {
     }
   });
 
+  describe('when validation mode is on with separate required fields', () => {
+    const options = new OptionsHelper({ validationMode: ValidationMode.C1Request });
+
+    it('should return no errors if all required fields are present', () => {
+      const data = {
+        type: 'Event',
+        duration: 'PT1H30M',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(0);
+    });
+
+    it('should return a failure per field if any required fields are missing', () => {
+      const data = {
+        type: 'Event',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(1);
+
+      for (const error of errors) {
+        expect(error.type).toBe(ValidationErrorType.MISSING_REQUIRED_FIELD);
+        expect(error.severity).toBe(ValidationErrorSeverity.FAILURE);
+      }
+    });
+  });
+
   describe('with inheritsTo properties', () => {
     it('should respect required fields when inheritsTo is *', () => {
       const modelObj = loadInheritanceModel();
@@ -296,6 +352,7 @@ describe('RequiredFieldsRule', () => {
     });
   });
 
+
   describe('with inheritsFrom properties', () => {
     it('should respect required fields when inheritsFrom is *', () => {
       const modelObj = loadInheritanceModel();

diff --git a/src/rules/core/required-fields-rule.js b/src/rules/core/required-fields-rule.js
@@ -32,7 +32,8 @@ module.exports = class RequiredFieldsRule extends Rule {
       return [];
     }
     const errors = [];
-    for (const field of node.model.requiredFields) {
+
+    for (const field of node.model.getRequiredFields(node.options.validationMode)) {
       const testValue = node.getValueWithInheritance(field);
       const example = node.model.getRenderedExample(field);
       if (typeof testValue === 'undefined') {

diff --git a/src/rules/core/required-optional-fields-rule-spec.js b/src/rules/core/required-optional-fields-rule-spec.js
@@ -3,6 +3,8 @@ const Model = require('../../classes/model');
 const ModelNode = require('../../classes/model-node');
 const ValidationErrorType = require('../../errors/validation-error-type');
 const ValidationErrorSeverity = require('../../errors/validation-error-severity');
+const ValidationMode = require('../../helpers/validation-mode');
+const OptionsHelper = require('../../helpers/options');
 
 describe('RequiredOptionalFieldsRule', () => {
   const model = new Model({
@@ -18,6 +20,21 @@ describe('RequiredOptionalFieldsRule', () => {
         ],
       },
     ],
+    validationMode: {
+      C1Request: 'request',
+    },
+    imperativeConfiguration: {
+      request: {
+        requiredOptions: [
+          {
+            options: [
+              'duration',
+              'endDate',
+            ],
+          },
+        ],
+      },
+    },
   }, 'latest');
   model.hasSpecification = true;
 
@@ -121,6 +138,49 @@ describe('RequiredOptionalFieldsRule', () => {
     expect(errors[0].path).toBe('$["startDate","schedule"]');
   });
 
+  describe('when validation mode is on with separate required fields', () => {
+    const options = new OptionsHelper({ validationMode: ValidationMode.C1Request });
+    it('should return no errors if required optional fields are present', () => {
+      const data = {
+        type: 'Event',
+        endDate: '2018-01-27T12:00:00Z',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(0);
+    });
+
+    it('should return a failure per option group if any required optional fields are missing', () => {
+      const data = {
+        type: 'Event',
+        startDate: '2018-01-27T12:00:00Z',
+      };
+
+      const nodeToTest = new ModelNode(
+        '$',
+        data,
+        null,
+        model,
+        options,
+      );
+      const errors = rule.validate(nodeToTest);
+
+      expect(errors.length).toBe(1);
+
+      expect(errors[0].type).toBe(ValidationErrorType.MISSING_REQUIRED_FIELD);
+      expect(errors[0].severity).toBe(ValidationErrorSeverity.FAILURE);
+      expect(errors[0].path).toBe('$["duration","endDate"]');
+    });
+  });
+
   describe('with inheritsTo properties', () => {
     it('should respect required optional fields when inheritsTo is *', () => {
       const modelObj = loadInheritanceModel();

diff --git a/src/rules/core/required-optional-fields-rule.js b/src/rules/core/required-optional-fields-rule.js
@@ -33,7 +33,8 @@ module.exports = class RequiredOptionalFieldsRule extends Rule {
       return [];
     }
     const errors = [];
-    for (const option of node.model.requiredOptions) {
+
+    for (const option of node.model.getRequiredOptions(node.options.validationMode)) {
       if (typeof (option.options) !== 'undefined'
           && option.options instanceof Array
       ) {