feat: removes "callback" argument of "validate"

BREAKING CHANGE: "gavel.validate()" no longer accepts a callback as an argument.
Please use the "validate()" function as follows:

const result = gavel.validate(expected, real)

Author: artem-zakharchenko

lib/next/validate.js

@@ -3,31 +3,11 @@ const { validateMessage } = require('./validateMessage');
 /**
  * Validates the given HTTP messages pair and returns
  * a legacy-compliant validation results.
- * @param {Object<string, key>} real
  * @param {Object<string, key>} expected
- * @param {(error: Error, result: Object<string, key>) => void} callback
+ * @param {Object<string, key>} real
  */
-function validate(expected, real, callback) {
-  let result;
-
-  try {
-    result = validateMessage(expected, real);
-  } catch (error) {
-    if (callback) {
-      callback(error, null);
-    }
-
-    return result;
-  }
-
-  if (callback) {
-    callback(null, {
-      version: '2',
-      ...result
-    });
-  }
-
-  return result;
+function validate(expected, real) {
+  return validateMessage(expected, real);
 }
 
 module.exports = validate;

test/cucumber/step_definitions/validation_errors_thens.js

@@ -3,15 +3,12 @@ const { assert } = require('chai');
 
 module.exports = function() {
   this.Then(/^Gavel will set some error for "([^"]*)"$/, function(
-    component,
+    rawComponentName,
     callback
   ) {
-    return this.validate((error, result) => {
-      if (error) {
-        callback(new Error(`Error during validation: ${error}`));
-      }
-
-      component = this.toCamelCase(component);
+    try {
+      const result = this.validate();
+      const component = this.toCamelCase(rawComponentName);
       const componentValidation = result.fields[component];
       const { errors } = componentValidation;
       const errorsCount = errors.length;
@@ -25,18 +22,18 @@ module.exports = function() {
       }
 
       return callback();
-    });
+    } catch (error) {
+      callback(new Error(`Error during validation: ${error}`));
+    }
   });
 
   this.Then(/^Gavel will NOT set any errors for "([^"]*)"$/, function(
-    component,
+    rawComponentName,
     callback
   ) {
-    return this.validate((error, result) => {
-      if (error) {
-        callback(new Error(`Error during validation: ${error}`));
-      }
-      component = this.toCamelCase(component);
+    try {
+      const result = this.validate();
+      const component = this.toCamelCase(rawComponentName);
       const componentValidation = result.fields[component];
       const { errors } = componentValidation;
       const errorsCount = errors.length;
@@ -55,80 +52,50 @@ module.exports = function() {
       }
 
       return callback();
-    });
+    } catch (error) {
+      callback(new Error(`Error during validation: ${error}`));
+    }
   });
 
   this.Then(/^field "([^"]*)" is( NOT)? valid$/, function(
     fieldName,
     isNotValid,
     callback
   ) {
-    return this.validate((error, result) => {
-      assert.property(
-        result.fields,
-        fieldName,
-        `Expected to have "${fieldName}" field in the validation result, but got none.`
-      );
-
-      assert.propertyVal(
-        result.fields[fieldName],
-        'isValid',
-        !isNotValid,
-        `Expected "result.fields.${fieldName}" to be valid, but it's not.`
-      );
-
-      return callback();
-    });
+    const result = this.validate();
+    assert.property(
+      result.fields,
+      fieldName,
+      `Expected to have "${fieldName}" field in the validation result, but got none.`
+    );
+
+    assert.propertyVal(
+      result.fields[fieldName],
+      'isValid',
+      !isNotValid,
+      `Expected "result.fields.${fieldName}" to be valid, but it's not.`
+    );
+
+    return callback();
   });
 
-  // TODO REMOVE THIS, no longer in spec
-  // this.Then(/^Gavel will set "([^"]*)" to "([^"]*)" for "([^"]*)"$/, function(
-  //   propName,
-  //   expectedValue,
-  //   componentName,
-  //   callback
-  // ) {
-  //   return this.validate((error, result) => {
-  //     console.log({ componentName, propName, expectedValue });
-  //     console.log({ result });
-
-  //     assert.property(
-  //       result.field,
-  //       componentName,
-  //       `Expected validation result to have property "${componentName}", but got "${Object.keys(
-  //         result
-  //       ).join('", "')}"`
-  //     );
-
-  //     assert.propertyVal(
-  //       result.field[componentName],
-  //       propName,
-  //       this.toBoolean(expectedValue)
-  //     );
-
-  //     return callback();
-  //   });
-  // });
-
   this.Then(/^Request or Response is NOT valid$/, function(callback) {
-    return this.validate((error, result) => {
-      if (result.isValid) {
-        callback(
-          new Error('Request or Response is valid and should NOT be valid.')
-        );
-      }
-      return callback();
-    });
+    const result = this.validate();
+    if (result.isValid) {
+      callback(
+        new Error('Request or Response is valid and should NOT be valid.')
+      );
+    }
+    return callback();
   });
 
   return this.Then(/^Request or Response is valid$/, function(callback) {
-    return this.validate((error, result) => {
-      if (!result.isValid) {
-        callback(
-          new Error('Request or Response is NOT valid and should be valid.')
-        );
-      }
-      return callback();
-    });
+    const result = this.validate();
+    if (!result.isValid) {
+      callback(
+        new Error('Request or Response is NOT valid and should be valid.')
+      );
+    }
+    return callback();
   });
 };

test/cucumber/step_definitions/validators_steps.js

@@ -26,20 +26,14 @@ module.exports = function() {
         body: json2
       };
 
-      return this.validate((error, result) => {
-        if (error) {
-          callback(new Error(`Got error during validation:\n${error}`));
-        }
+      try {
+        const result = this.validate();
         this.results = JSON.parse(JSON.stringify(result));
-
-        return this.validate((error, result) => {
-          if (error) {
-            callback(new Error(error));
-          }
-          this.booleanResult = result.isValid;
-          return callback();
-        });
-      });
+        this.booleanResult = result.isValid;
+        return callback();
+      } catch (error) {
+        callback(new Error(`Got error during validation:\n${error}`));
+      }
     }
   );
 
@@ -166,15 +160,14 @@ module.exports = function() {
   this.When(/^you perform validation on the HTTP component$/, function(
     callback
   ) {
-    return this.validate((error, result) => {
-      if (error) {
-        callback(new Error(`Error during validation: ${error}`));
-      }
-
+    try {
+      const result = this.validate();
       this.results = result;
       this.componentResults = this.results.fields[this.component];
       return callback();
-    });
+    } catch (error) {
+      callback(new Error(`Error during validation: ${error}`));
+    }
   });
 
   this.Then(/^validator "([^"]*)" is used for validation$/, function(

test/cucumber/support/world.js

@@ -111,8 +111,8 @@ class World {
     }
   }
 
-  validate(callback) {
-    return gavel.validate(this.expected, this.real, callback);
+  validate() {
+    return gavel.validate(this.expected, this.real);
   }
 
   parseHeaders(headersString) {

test/unit/validate-test.js

@@ -46,53 +46,20 @@ describe('Gavel proxies to functions with callbacks', () => {
     describe('when I provide data', () => {
       ['response', 'request'].forEach((variant) => {
         describe(`for two cloned ${variant}s`, () => {
-          let results = null;
-          let error = null;
+          const results = validate(baseHttpMessage, cloneHttpMessage);
 
-          before((done) => {
-            validate(baseHttpMessage, cloneHttpMessage, (err, result) => {
-              error = err;
-              results = result;
-              done();
-            });
-          });
-
-          it('should call the callback without any errors', () =>
-            assert.isNull(error));
           it('should results be an object', () => assert.isObject(results));
         });
 
         describe(`for similar ${variant}s`, () => {
-          let results = null;
-          let error = null;
-
-          before((done) => {
-            validate(baseHttpMessage, similarHttpMessage, (err, result) => {
-              error = err;
-              results = result;
-              done();
-            });
-          });
+          const results = validate(baseHttpMessage, similarHttpMessage);
 
-          it('should call the callback without any errors', () =>
-            assert.isNull(error));
           it('should results be an object', () => assert.isObject(results));
         });
 
         describe(`for different ${variant}s`, () => {
-          let results = null;
-          let error = null;
-
-          before((done) => {
-            validate(baseHttpMessage, differentHttpMessage, (err, result) => {
-              error = err;
-              results = result;
-              done();
-            });
-          });
+          const results = validate(baseHttpMessage, differentHttpMessage);
 
-          it('should call the callback without any errors', () =>
-            assert.isNull(error));
           it('should results be an object', () => assert.isObject(results));
           it('should results contain 2 different headers messages (missing content-length, different content-type)', () => {
             assert.isObject(results);