test: added a new test setup to verify for warnings

Author: abdul99ahad

packages/element-templates-json-schema-shared/test/helpers/index.js

@@ -10,11 +10,13 @@ const AjvErrors = require('ajv-errors');
 
 module.exports = {
   createValidator,
-  withErrorMessages
+  withErrorMessages,
+  withDeprecationWarnings
 };
 
-function createValidator(schema, errors) {
+function createValidator(schema, errors, deprecations) {
 
+  let deprecationWarnings = [];
   const ajv = new Ajv({
     allErrors: true,
     strict: false,
@@ -23,7 +25,59 @@ function createValidator(schema, errors) {
 
   AjvErrors(ajv);
 
-  return ajv.compile(withErrorMessages(schema, errors));
+  ajv.addKeyword({
+    keyword: 'isDeprecated',
+    errors: true,
+    compile(schema, parentSchema) {
+      return function(data, dataCtx) {
+        if (schema) {
+          deprecationWarnings = [];
+
+          // AJV doesn't support real warnings, so this adds a non-strict validation with keyword 'isDeprecated'
+          const deprecationWarning = {
+            keyword: 'isDeprecated',
+
+            // TODO: schemaPath
+            dataPath: dataCtx.dataPath,
+            message: parentSchema.deprecatedWarning || 'This property is deprecated',
+          };
+
+          deprecationWarnings.push({
+            id: dataCtx.rootData.id,
+            warningDescription: deprecationWarning,
+          });
+
+          // just return true to not fail validation
+          // AJV will not throw an error, but will add the deprecation warning to the
+          // validator.errors array
+          return true;
+        }
+        return true;
+      };
+    }
+  });
+
+  const validator = ajv.compile(withErrorMessages(withDeprecationWarnings(schema, deprecations), errors));
+
+
+  const getDeprecationWarnings = function(data) {
+    if (deprecationWarnings.length > 0 && data.id === deprecationWarnings[0].id) {
+      return deprecationWarnings.map(warning => warning.warningDescription);
+    }
+  };
+
+  // wrapper function checks for warnings before each validation
+  const wrappedValidator = function(data, ...args) {
+
+    const result = validator.call(this, data, ...args);
+
+    wrappedValidator.errors = validator.errors;
+    wrappedValidator.warnings = getDeprecationWarnings(data);
+
+    return result;
+  };
+
+  return wrappedValidator;
 }
 
 function withErrorMessages(schema, errors) {
@@ -71,4 +125,34 @@ function eqlErrors(chai, utils) {
   });
 }
 
-chai.use(eqlErrors);
+chai.use(eqlErrors);
+
+function withDeprecationWarnings(schema, deprecations) {
+  if (!deprecations || !deprecations.length) {
+    return schema;
+  }
+
+  // clone a new copy
+  let newSchema = JSON.parse(JSON.stringify(schema));
+
+  // set deprecation warnings for given paths
+  forEach(deprecations, function(deprecation) {
+    newSchema = setDeprecationWarning(newSchema, deprecation);
+  });
+
+  return newSchema;
+}
+
+function setDeprecationWarning(schema, deprecation) {
+  const {
+    path,
+    warningMessage
+  } = deprecation;
+
+  const deprecationPath = [
+    ...path,
+    'deprecatedWarning'
+  ];
+
+  return set(schema, deprecationPath, warningMessage);
+}

packages/zeebe-element-templates-json-schema/src/defs/properties.json

@@ -646,7 +646,7 @@
                   { "required": [ "generatedValue" ] }
                 ]
               },
-              "deprecated": true
+              "isDeprecated": true
             }
           ]
         }

packages/zeebe-element-templates-json-schema/test/fixtures/binding-type/additional-property.js

@@ -16,4 +16,12 @@ export const template = {
   ]
 };
 
-export const errors = null;
+export const errors = null;
+
+export const warnings = [
+  {
+    keyword: 'isDeprecated',
+    dataPath: '/properties/0',
+    message: 'Hidden property must specify either "value" or "generatedValue"'
+  }
+];

packages/zeebe-element-templates-json-schema/test/fixtures/hidden-property.js

@@ -1,5 +1,6 @@
 export const template = {
   'name': 'HiddenProperty',
+  '$schema': '../../resources/schema.json',
   'id': 'com.camunda.example.HiddenProperty',
   'appliesTo': [
     'bpmn:Task'
@@ -10,20 +11,28 @@ export const template = {
   'properties': [
     {
       'type': 'Hidden',
-      'value': 'decision',
       'binding': {
-        'type': 'zeebe:calledDecision',
-        'property': 'decisionId'
+        'type': 'property',
+        'name': 'resultVariable'
       }
     },
     {
       'type': 'Hidden',
+      'value': 'hiddenValue',
       'binding': {
-        'type': 'zeebe:calledDecision',
-        'property': 'resultVariable'
+        'type': 'property',
+        'name': 'resultVariable'
       }
     }
   ]
 };
 
 export const errors = null;
+
+export const warnings = [
+  {
+    keyword: 'isDeprecated',
+    dataPath: '/properties/0',
+    message: 'Hidden property must specify either "value" or "generatedValue"'
+  }
+];

packages/zeebe-element-templates-json-schema/test/spec/validationSpec.js

@@ -5,12 +5,13 @@ const util = require('util');
 const schema = require('../../resources/schema.json');
 
 const errorMessages = require('../../resources/error-messages.json');
+const deprecatedWarnings = require('../../resources/deprecated-warnings.json');
 
 const {
   createValidator
 } = require('../../../element-templates-json-schema-shared/test/helpers');
 
-const validator = createValidator(schema, errorMessages);
+const validator = createValidator(schema, errorMessages, deprecatedWarnings);
 
 // we save this for some other shinanigans
 const iit = it;
@@ -20,10 +21,12 @@ function validateTemplate(template) {
   const valid = validator(template);
 
   const errors = validator.errors;
+  const warnings = validator.warnings;
 
   return {
     valid,
-    errors
+    errors,
+    warnings
   };
 }
 
@@ -40,16 +43,19 @@ function createTest(name, file, it) {
 
     const {
       errors: expectedErrors,
-      template
+      template,
+      warnings: expectedWarnings
     } = testDefinition;
 
     // when
     const {
-      errors
+      errors,
+      warnings
     } = validateTemplate(template);
 
     // then
     expect(errors).to.eqlErrors(expectedErrors);
+    expect(warnings).to.eql(expectedWarnings);
   });
 }