fix: uses strict json parsing for actual body, weak for expected body

Author: artem-zakharchenko

lib/units/validateBody.js

@@ -69,7 +69,11 @@ function getBodyType(body, contentType, httpMessageOrigin) {
   const hasJsonContentType = isJsonContentType(contentType);
 
   try {
-    parseJson(body);
+    // Use strict JSON parsing for actual body.
+    // This prevents any kind of normalization of trailing commas
+    // and other custom transformations applied by "jju".
+    parseJson(body, httpMessageOrigin === 'actual');
+
     const bodyMediaType = parseContentType(
       hasJsonContentType ? contentType : 'application/json'
     );

lib/utils/parseJson.js

@@ -1,8 +1,14 @@
 const { parse } = require('jju/lib/parse');
 
-const parseJson = (json, revivew) => {
+const parseJson = (json, strict = false, revivew) => {
   try {
-    return parse(json, revivew);
+    // Strict parsing uses native JSON parsing and implies
+    // a given JSON is valid according to the spec.
+    //
+    // Non-strict parsing uses "jju" enhanced parsing
+    // that allows trailing commas and potential other transformations.
+    const jsonParser = strict ? JSON.parse : parse;
+    return jsonParser(json, revivew);
   } catch (error) {
     throw error;
   }

lib/utils/schema-v4-generator.js

@@ -1,4 +1,5 @@
 const getType = require('./get-type');
+const parseJson = require('./parseJson');
 
 const SCHEMA_VERSION = 'http://json-schema.org/draft-04/schema#';
 
@@ -30,7 +31,7 @@ class SchemaV4Generator {
    * @option {SchemaProperties} properties
    */
   constructor({ json, properties }) {
-    this.json = typeof json === 'string' ? JSON.parse(json) : json;
+    this.json = typeof json === 'string' ? parseJson(json) : json;
 
     this.schema = undefined;
     this.properties = properties || new SchemaV4Properties({});

lib/validators/json-schema.js

@@ -3,6 +3,7 @@ const deepEqual = require('deep-equal');
 const tv4 = require('tv4');
 const jsonPointer = require('json-pointer');
 
+const parseJson = require('../utils/parseJson');
 const metaSchemaV3 = require('../meta-schema-v3');
 const metaSchemaV4 = require('../meta-schema-v4');
 const errors = require('../errors');
@@ -89,7 +90,7 @@ class JsonSchema {
 
     if (typeof this.data === 'string') {
       try {
-        this.data = JSON.parse(this.data);
+        this.data = parseJson(this.data);
       } catch (error) {
         const outError = new errors.DataNotJsonParsableError(
           `JSON validator: body: ${error.message}`
@@ -101,7 +102,7 @@ class JsonSchema {
 
     if (typeof this.schema === 'string') {
       try {
-        this.schema = JSON.parse(this.schema);
+        this.schema = parseJson(this.schema);
       } catch (error) {
         const outError = new errors.SchemaNotJsonParsableError(
           `JSON validator: schema: ${error.message}`

test/chai.js

@@ -13,7 +13,7 @@ chai.use(({ Assertion }, utils) => {
       const { currentError: error, currentErrorIndex } = this.__flags;
       const target = error[propName];
       const isRegExp = expectedValue instanceof RegExp;
-      const matchWord = isRegExp ? 'matches' : 'equals';
+      const matchWord = isRegExp ? 'matches the following RegExp' : 'equals';
 
       new Assertion(error).to.be.instanceOf(Object);
       new Assertion(error).to.have.property(propName);
@@ -29,7 +29,7 @@ ${stringifiedObj}
 
 to have an error at index ${currentErrorIndex} that includes property "${propName}" that ${matchWord}:
 
-${JSON.stringify(expectedValue)}
+${isRegExp ? expectedValue.toString() : JSON.stringify(expectedValue)}
 
 but got:
 
@@ -45,7 +45,7 @@ to have an error at index ${currentErrorIndex} that includes property "${propNam
 ${JSON.stringify(target)}
   `,
         JSON.stringify(target),
-        JSON.stringify(expectedValue),
+        isRegExp ? expectedValue.toString() : JSON.stringify(expectedValue),
         true
       );
     });

test/fixtures/invalid-stringified-schema.js

@@ -1 +1,4 @@
-module.exports = `{"111!invalid string ... issue":''}`;
+// Note that Json Schema now uses "jju" for JSON parsing
+// which allows certain JSON abnormalities (i.e. trailing commas, single quotes).
+// Account on that to produce an invalid JSON.
+module.exports = `{"111!invalid string ... issue":malformed''}`;

test/regression/missing-expected-header.test.js

@@ -0,0 +1,34 @@
+const { expect } = require('../chai');
+const { validate } = require('../../lib/validate');
+
+describe('Regression: Missing expected header', () => {
+  const actualResponse = {
+    method: 'POST',
+    headers: {
+      host: 'private-54408-mynotesapi.apiary-mock.test:8001',
+      'content-length': '27',
+      connection: 'keep-alive'
+    },
+    body: '{"id":2,"title":"Buy milk"}'
+  };
+  const result = validate(
+    {
+      method: 'POST',
+      headers: {},
+      body: '',
+      headersSchema: null,
+      bodySchema: null
+    },
+    actualResponse
+  );
+
+  it('should contain "headers.values.expected" as empty Object', () => {
+    expect(result.fields.headers.values.expected).to.deep.equal({});
+  });
+
+  it('should contain "headers.values.actual"', () => {
+    expect(result.fields.headers.values.actual).to.deep.equal(
+      actualResponse.headers
+    );
+  });
+});

test/regression/unparseable-json.test.js

@@ -0,0 +1,90 @@
+const { expect } = require('../chai');
+const { validateBody } = require('../../lib/units/validateBody');
+
+describe('Regression: Unparseable JSON body', () => {
+  describe('given unparseable JSON as expected body', () => {
+    const result = validateBody(
+      {
+        headers: {
+          'content-type': 'application/json'
+        },
+        body: `{ "username": "adm02", }`,
+        bodySchema: null
+      },
+      {
+        body: `{ "username": "adm03" }`,
+        headers: {
+          'content-type': 'application/json'
+        }
+      }
+    );
+
+    it('marks field as invalid', () => {
+      expect(result).to.be.valid;
+    });
+
+    it('has "json" kind', () => {
+      expect(result).to.have.kind('json');
+    });
+
+    it('has values', () => {
+      expect(result).to.have.property('values');
+      expect(result.values).to.deep.equal({
+        expected: `{ "username": "adm02", }`,
+        actual: '{ "username": "adm03" }'
+      });
+    });
+
+    it('has no errors', () => {
+      expect(result).to.not.have.errors;
+    });
+  });
+
+  describe('given unparseable JSON as actual body', () => {
+    const result = validateBody(
+      {
+        headers: {
+          'content-type': 'application/json'
+        },
+        body: `{ "firstName": "John" }`,
+        bodySchema: null
+      },
+      {
+        body: `{ "firstName": "Kyle", }`,
+        headers: {
+          'content-type': 'application/json'
+        }
+      }
+    );
+
+    it('marks field as invalid', () => {
+      expect(result).to.not.be.valid;
+    });
+
+    it('has "null" kind', () => {
+      expect(result).to.have.kind(null);
+    });
+
+    it('has values', () => {
+      expect(result).to.have.property('values');
+      expect(result.values).to.deep.equal({
+        expected: `{ "firstName": "John" }`,
+        actual: `{ "firstName": "Kyle", }`
+      });
+    });
+
+    describe('produces an error', () => {
+      it('exactly one error', () => {
+        expect(result).to.have.errors.lengthOf(1);
+      });
+
+      it('has error message about unparseable actual body', () => {
+        expect(result)
+          .to.have.errorAtIndex(0)
+          .withMessage(
+            /^Can't validate: actual body 'Content-Type' header is 'application\/json' but body is not a parseable JSON:/
+          );
+      });
+    });
+  });
+});

test/unit/validators/json-schema.test.js

@@ -149,6 +149,17 @@ describe('JsonSchema', () => {
       assert.isDefined(validator.validateSchema);
     });
 
+    describe('when invalid, but jju-compliant, JSON-stringified-data are provided', () => {
+      const invalidJjuCompliantSchema = `{"foo":'key',}`;
+
+      it('should not throw an error', () => {
+        const fn = () => {
+          new JsonSchema(invalidJjuCompliantSchema);
+        };
+        assert.doesNotThrow(fn);
+      });
+    });
+
     describe('when invalid JSON-stringified-data are provided', () => {
       const invalidStringifiedSchema = require('../../fixtures/invalid-stringified-schema');