Merge pull request #259 from apiaryio/validate-body-polishing

Adopts "actual" terminology in "validateBody"

Author: artem-zakharchenko

lib/units/validateBody.js

@@ -62,7 +62,7 @@ function isJsonContentType(contentType) {
  * on the given body and normalized headers.
  * @param {string} body
  * @param {string} contentType
- * @param {'real'|'expected'} httpMessageOrigin
+ * @param {'actual'|'expected'} httpMessageOrigin
  * @returns {[string, MediaType]}
  */
 function getBodyType(body, contentType, httpMessageOrigin) {
@@ -116,14 +116,14 @@ ${error.message}\
 
 /**
  * Returns a body validator class based on the given
- * real and expected body media types.
- * @param {MediaType} realType
+ * actual and expected body media types.
  * @param {MediaType} expectedType
+ * @param {MediaType} actualType
  * @returns {Validator}
  */
-function getBodyValidator(realType, expectedType) {
-  const both = (predicate) => (real, expected) => {
-    return [real, expected].every(predicate);
+function getBodyValidator(expectedType, actualType) {
+  const both = (predicate) => (expected, actual) => {
+    return [expected, actual].every(predicate);
   };
 
   const validators = [
@@ -132,21 +132,21 @@ function getBodyValidator(realType, expectedType) {
     // would resolve on "application/schema+json" media type too.
     [
       JsonSchema,
-      (real, expected) => {
-        return isJson(real) && isJsonSchema(expected);
+      (expected, actual) => {
+        return isJson(actual) && isJsonSchema(expected);
       },
       'json'
     ],
     [JsonExample, both(isJson), 'json']
   ];
 
   const validator = validators.find(([_name, predicate]) => {
-    return predicate(realType, expectedType);
+    return predicate(expectedType, actualType);
   });
 
   if (!validator) {
     const error = `Can't validate actual media type '${mediaTyper.format(
-      realType
+      actualType
     )}' against the expected media type '${mediaTyper.format(expectedType)}'.`;
     return [error, null, null];
   }
@@ -157,7 +157,7 @@ function getBodyValidator(realType, expectedType) {
 /**
  * Validates given bodies of transaction elements.
  * @param {Object<string, any>} expected
- * @param {Object<string, any>} real
+ * @param {Object<string, any>} actual
  */
 function validateBody(expected, actual) {
   const values = {
@@ -171,20 +171,20 @@ function validateBody(expected, actual) {
   }
 
   const errors = [];
-  const realBodyType = typeof actual.body;
-  const hasEmptyRealBody = actual.body === '';
+  const actualBodyType = typeof actual.body;
+  const hasEmptyActualBody = actual.body === '';
 
-  // Throw when user input for real body is not a string.
-  if (realBodyType !== 'string') {
+  // Throw when user input for actual body is not a string.
+  if (actualBodyType !== 'string') {
     throw new Error(
-      `Expected HTTP body to be a string, but got: ${realBodyType}`
+      `Expected HTTP body to be a string, but got: ${actualBodyType}`
     );
   }
 
-  const [realTypeError, realType] = getBodyType(
+  const [actualTypeError, actualType] = getBodyType(
     actual.body,
     actual.headers && actual.headers['content-type'],
-    'real'
+    'actual'
   );
 
   const [expectedTypeError, expectedType] = expected.bodySchema
@@ -195,9 +195,9 @@ function validateBody(expected, actual) {
         'expected'
       );
 
-  if (realTypeError) {
+  if (actualTypeError) {
     errors.push({
-      message: realTypeError
+      message: actualTypeError
     });
   }
 
@@ -210,18 +210,18 @@ function validateBody(expected, actual) {
   const hasErrors = errors.length > 0;
 
   // Skipping body validation in case errors during
-  // real/expected body type definition.
+  // actual/expected body type definition.
   const [validatorError, ValidatorClass, kind] = hasErrors
     ? [null, null, null]
-    : getBodyValidator(realType, expectedType);
+    : getBodyValidator(expectedType, actualType);
 
   if (validatorError) {
-    // In case determined media types mismtach, check if the real is not missing.
+    // In case determined media types mismtach, check if the actual is not missing.
     // Keep in mind the following scenarios:
     // 1. Expected '', and got '' (TextDiff/TextDiff, valid)
-    // 2. Expected {...}, but got '' (Json/TextDiff, invalid, produces "missing real body" error)
+    // 2. Expected {...}, but got '' (Json/TextDiff, invalid, produces "missing actual body" error)
     // 3. Expected {...}, but got "foo" (Json/TextDiff, invalid, produces types mismatch error).
-    if (expected.body !== '' && hasEmptyRealBody) {
+    if (expected.body !== '' && hasEmptyActualBody) {
       errors.push({
         message: `Expected "body" of "${mediaTyper.format(
           expectedType

lib/validators/json-example.js

@@ -18,11 +18,11 @@ function getSchema(json) {
 class JsonExample extends JsonSchema {
   /**
    * Construct a BodyValidator, check data and choose the right validator.
-   * If real and expected data are valid JSON, and a valid schema is given,
+   * If actual and expected data are valid JSON, and a valid schema is given,
    * choose JsonValidator, otherwise choose StringValidator.
-   * @param {string} real
    * @param {string} expected
-   * @throw {MalformedDataError} when real is not a String or when no schema provided and expected is not a String
+   * @param {string} actual
+   * @throw {MalformedDataError} when actual is not a String or when no schema provided and expected is not a String
    * @throw {SchemaNotJsonParsableError} when given schema is not a json parsable string or valid json
    * @throw {NotEnoughDataError} when at least one of expected data and json schema is not given
    */

lib/validators/text-diff.js

@@ -34,11 +34,7 @@ class TextDiff {
 
     return [
       {
-        message: 'Actual and expected data do not match.',
-        values: {
-          expected: this.expected,
-          actual: this.actual
-        }
+        message: 'Actual and expected data do not match.'
       }
     ];
   }

test/unit/units/validateBody.test.js

@@ -108,7 +108,7 @@ describe('validateBody', () => {
               expect(result)
                 .to.have.errorAtIndex(0)
                 .withMessage(
-                  /^Can't validate: real body 'Content-Type' header is 'application\/json' but body is not a parseable JSON:/
+                  /^Can't validate: actual body 'Content-Type' header is 'application\/json' but body is not a parseable JSON:/
                 );
             });
           });
@@ -172,7 +172,7 @@ describe('validateBody', () => {
               expect(result)
                 .to.have.errorAtIndex(0)
                 .withMessage(
-                  /^Can't validate: real body 'Content-Type' header is 'application\/hal\+json' but body is not a parseable JSON:/
+                  /^Can't validate: actual body 'Content-Type' header is 'application\/hal\+json' but body is not a parseable JSON:/
                 );
             });
           });

test/unit/units/validateBody/getBodyValidator.test.js

@@ -2,8 +2,8 @@ const { assert } = require('chai');
 const mediaTyper = require('media-typer');
 const { getBodyValidator } = require('../../../../lib/units/validateBody');
 
-const getMediaTypes = (real, expected) => {
-  return [real, expected].map(mediaTyper.parse);
+const getMediaTypes = (expected, actual) => {
+  return [expected, actual].map(mediaTyper.parse);
 };
 
 describe('getBodyValidator', () => {
@@ -14,7 +14,7 @@ describe('getBodyValidator', () => {
         expectedValidator: 'JsonExample'
       },
       {
-        contentTypes: ['application/json', 'application/schema+json'],
+        contentTypes: ['application/schema+json', 'application/json'],
         expectedValidator: 'JsonSchema'
       },
       {
@@ -24,14 +24,14 @@ describe('getBodyValidator', () => {
     ];
 
     knownContentTypes.forEach(({ contentTypes, expectedValidator }) => {
-      const [realContentType, expectedContentType] = contentTypes;
-      const [real, expected] = getMediaTypes(
-        realContentType,
-        expectedContentType
+      const [expectedContentType, actualContentType] = contentTypes;
+      const [expected, actual] = getMediaTypes(
+        expectedContentType,
+        actualContentType
       );
 
-      describe(`${realContentType} + ${expectedContentType}`, () => {
-        const [error, validator] = getBodyValidator(real, expected);
+      describe(`${expectedContentType} + ${actualContentType}`, () => {
+        const [error, validator] = getBodyValidator(expected, actual);
 
         it('returns no error', () => {
           assert.isNull(error);

test/unit/validators/text-diff.test.js

@@ -80,13 +80,6 @@ describe('TextDiff', () => {
           'Actual and expected data do not match.'
         );
       });
-
-      it('error should contain compared values', () => {
-        expect(result[0]).to.have.deep.property('values', {
-          expected: 'john',
-          actual: 'barry'
-        });
-      });
     });
   });
 });