feat: adds "kind", "values" field properties, removes deprecations

BREAKING CHANGE:

- Gavel fields no longer contain the following properties:
  - `validator`
  - `expectedType`
  - `realType`
  - `rawData`
- Gavel fields now contain the next new properies:
  - `kind`
  - `values` (optional)

Author: artem-zakharchenko

lib/units/validateBody.js

@@ -126,16 +126,17 @@ function getBodyValidator(realType, expectedType) {
   };
 
   const validators = [
-    [TextDiff, both(isPlainText)],
+    [TextDiff, both(isPlainText), 'text'],
     // List JsonSchema first, because weak predicate of JsonExample
     // would resolve on "application/schema+json" media type too.
     [
       JsonSchema,
       (real, expected) => {
         return isJson(real) && isJsonSchema(expected);
-      }
+      },
+      'json'
     ],
-    [JsonExample, both(isJson)]
+    [JsonExample, both(isJson), 'json']
   ];
 
   const validator = validators.find(([_name, predicate]) => {
@@ -146,10 +147,10 @@ function getBodyValidator(realType, expectedType) {
     const error = `Can't validate real media type '${mediaTyper.format(
       realType
     )}' against expected media type '${mediaTyper.format(expectedType)}'.`;
-    return [error, null];
+    return [error, null, null];
   }
 
-  return [null, validator[0]];
+  return [null, validator[0], validator[2]];
 }
 
 /**
@@ -161,6 +162,10 @@ function validateBody(expected, real) {
   const errors = [];
   const realBodyType = typeof real.body;
   const hasEmptyRealBody = real.body === '';
+  const values = {
+    expected: expected.body,
+    actual: real.body
+  };
 
   // Throw when user input for real body is not a string.
   if (realBodyType !== 'string') {
@@ -185,22 +190,24 @@ function validateBody(expected, real) {
 
   if (realTypeError) {
     errors.push({
-      message: realTypeError
+      message: realTypeError,
+      values
     });
   }
 
   if (expectedTypeError) {
     errors.push({
-      message: expectedTypeError
+      message: expectedTypeError,
+      values
     });
   }
 
   const hasErrors = errors.length > 0;
 
   // Skipping body validation in case errors during
   // real/expected body type definition.
-  const [validatorError, ValidatorClass] = hasErrors
-    ? [null, null]
+  const [validatorError, ValidatorClass, kind] = hasErrors
+    ? [null, null, null]
     : getBodyValidator(realType, expectedType);
 
   if (validatorError) {
@@ -213,11 +220,13 @@ function validateBody(expected, real) {
       errors.push({
         message: `Expected "body" of "${mediaTyper.format(
           expectedType
-        )}" media type, but actual "body" is missing.`
+        )}" media type, but actual "body" is missing.`,
+        values
       });
     } else {
       errors.push({
-        message: validatorError
+        message: validatorError,
+        values
       });
     }
   }
@@ -229,16 +238,15 @@ function validateBody(expected, real) {
       real.body,
       usesJsonSchema ? expected.bodySchema : expected.body
     );
-  const rawData = validator && validator.validate();
+  // Without ".validate()" it cannot evaluate output to result.
+  // TODO Re-do this.
+  validator && validator.validate();
   const validationErrors = validator ? validator.evaluateOutputToResults() : [];
   errors.push(...validationErrors);
 
   return {
-    isValid: isValidField({ errors }),
-    validator: ValidatorClass && ValidatorClass.name,
-    realType: mediaTyper.format(realType),
-    expectedType: mediaTyper.format(expectedType),
-    rawData,
+    valid: isValidField({ errors }),
+    kind,
     errors
   };
 }

lib/units/validateHeaders.js

@@ -26,7 +26,9 @@ function validateHeaders(expected, real) {
   const validator = hasJsonHeaders
     ? new HeadersJsonExample(real.headers, expected.headers)
     : null;
-  const rawData = validator && validator.validate();
+
+  // if you don't call ".validate()", it never evaluates any results.
+  validator && validator.validate();
 
   if (validator) {
     errors.push(...validator.evaluateOutputToResults());
@@ -42,11 +44,8 @@ and expected data media type
   }
 
   return {
-    isValid: isValidField({ errors }),
-    validator: validator && 'HeadersJsonExample',
-    realType,
-    expectedType,
-    rawData,
+    valid: isValidField({ errors }),
+    kind: hasJsonHeaders ? 'json' : 'text',
     errors
   };
 }

lib/units/validateMethod.js

@@ -1,22 +1,22 @@
-const APIARY_METHOD_TYPE = 'text/vnd.apiary.method';
-
 function validateMethod(expected, real) {
   const { method: expectedMethod } = expected;
   const { method: realMethod } = real;
-  const isValid = realMethod === expectedMethod;
+  const valid = realMethod === expectedMethod;
   const errors = [];
 
-  if (!isValid) {
+  if (!valid) {
     errors.push({
-      message: `Expected "method" field to equal "${expectedMethod}", but got "${realMethod}".`
+      message: `Expected "method" field to equal "${expectedMethod}", but got "${realMethod}".`,
+      values: {
+        expected: expectedMethod,
+        actual: realMethod
+      }
     });
   }
 
   return {
-    isValid,
-    validator: null,
-    realType: APIARY_METHOD_TYPE,
-    expectedType: APIARY_METHOD_TYPE,
+    valid,
+    kind: 'text',
     errors
   };
 }

lib/units/validateStatusCode.js

@@ -1,28 +1,25 @@
-const APIARY_STATUS_CODE_TYPE = 'text/vnd.apiary.status-code';
-
 /**
  * Validates given real and expected status codes.
  * @param {Object} real
  * @param {number} expected
  */
 function validateStatusCode(expected, real) {
-  const isValid = real.statusCode === expected.statusCode;
+  const valid = real.statusCode === expected.statusCode;
   const errors = [];
 
-  if (!isValid) {
+  if (!valid) {
     errors.push({
-      message: `Status code is '${real.statusCode}' instead of '${
-        expected.statusCode
-      }'`
+      message: `Status code is '${real.statusCode}' instead of '${expected.statusCode}'`,
+      values: {
+        expected: expected.statusCode,
+        actual: real.statusCode
+      }
     });
   }
 
   return {
-    isValid,
-    validator: 'TextDiff',
-    realType: APIARY_STATUS_CODE_TYPE,
-    expectedType: APIARY_STATUS_CODE_TYPE,
-    rawData: '',
+    valid,
+    kind: 'text',
     errors
   };
 }

lib/units/validateURI.js

@@ -1,8 +1,6 @@
 const url = require('url');
 const deepEqual = require('deep-equal');
 
-const APIARY_URI_TYPE = 'text/vnd.apiary.uri';
-
 /**
  * Parses the given URI and returns the properties
  * elligible for comparison. Leaves out raw properties like "path"
@@ -20,32 +18,34 @@ const parseURI = (uri) => {
   };
 };
 
-const validateURI = (expected, real) => {
+const validateURI = (expected, actual) => {
   const { uri: expectedURI } = expected;
-  const { uri: realURI } = real;
+  const { uri: actualURI } = actual;
 
   // Parses URI to perform a correct comparison:
   // - literal comparison of pathname
   // - order-insensitive comparison of query parameters
-  const parsedExpected = parseURI(expectedURI, true);
-  const parsedReal = parseURI(realURI, true);
+  const parsedExpected = parseURI(expectedURI);
+  const parsedActual = parseURI(actualURI);
 
   // Note the different order of arguments between
   // "validateURI" and "deepEqual".
-  const isValid = deepEqual(parsedReal, parsedExpected);
+  const valid = deepEqual(parsedActual, parsedExpected);
   const errors = [];
 
-  if (!isValid) {
+  if (!valid) {
     errors.push({
-      message: `Expected "uri" field to equal "${expectedURI}", but got: "${realURI}".`
+      message: `Expected "uri" field to equal "${expectedURI}", but got: "${actualURI}".`,
+      values: {
+        expected: expectedURI,
+        actual: actualURI
+      }
     });
   }
 
   return {
-    isValid,
-    validator: null,
-    expectedType: APIARY_URI_TYPE,
-    realType: APIARY_URI_TYPE,
+    valid,
+    kind: 'text',
     errors
   };
 };

lib/validate.js

@@ -47,7 +47,7 @@ function validate(expectedMessage, realMessage) {
   }
 
   // Indicates the validity of the real message
-  result.isValid = isValidResult(result);
+  result.valid = isValidResult(result);
 
   return result;
 }