refactor: adds "validateBody" unit

Author: artem-zakharchenko

lib/api/test/unit/validateBody.test.js

@@ -0,0 +1,110 @@
+const { assert } = require('chai');
+const validateBody = require('../../units/validateBody');
+
+describe.only('validateBody', () => {
+  describe('when given unsupported body type', () => {
+    const scenarios = [
+      { name: 'number', value: 5 },
+      { name: 'array', value: ['foo', 'bar'] },
+      { name: 'object', value: { foo: 'bar' } },
+      { name: 'null', value: null },
+      { name: 'undefined', value: undefined }
+    ];
+
+    scenarios.forEach(({ name, value }) => {
+      it(`errors when given ${name}`, () => {
+        assert.throw(() => validateBody({ body: value }, { body: value }));
+      });
+    });
+  });
+
+  describe('when given supported body type', () => {
+    describe('with explicit Content-Type header', () => {
+      describe('application/json', () => {
+        describe('and the body type matches content-type', () => {
+          const res = validateBody(
+            {
+              body: '{ "foo": "bar" }',
+              headers: { 'Content-Type': 'application/json' }
+            },
+            { body: '{ "foo": "bar" }' }
+          );
+
+          it('has proper real type', () => {
+            assert.propertyVal(res, 'realType', 'application/json');
+          });
+        });
+
+        describe('and the body does not match content-type', () => {
+          const res = validateBody(
+            {
+              body: 'foo',
+              headers: { 'content-type': 'application/json' }
+            },
+            { body: '{ "foo": "bar" }' }
+          );
+
+          it('uses plain/text as real type', () => {
+            assert.propertyVal(res, 'realType', 'text/plain');
+          });
+
+          describe('produces error', () => {
+            it('has proper severity', () => {
+              assert.propertyVal(res.results[0], 'severity', 'error');
+            });
+            it('has explanatory message', () => {
+              assert.match(
+                res.results[0].message,
+                /^Real body 'Content-Type' header is 'application\/json' but body is not a parseable JSON:/
+              );
+            });
+          });
+        });
+      });
+    });
+
+    describe('without explicit Content-Type header', () => {
+      describe('text/plain', () => {
+        describe('and the bodies match', () => {
+          const res = validateBody({ body: 'foo' }, { body: 'foo' });
+
+          it('has proper real type', () => {
+            assert.propertyVal(res, 'realType', 'text/plain');
+          });
+        });
+
+        describe('and the bodies do not match', () => {
+          const res = validateBody({ body: 'foo ' }, { body: 'bar' });
+
+          it('has proper real type', () => {
+            assert.propertyVal(res, 'realType', 'text/plain');
+          });
+        });
+      });
+
+      describe('application/json', () => {
+        describe('and the bodies match', () => {
+          const res = validateBody(
+            { body: '{ "foo": "bar" }' },
+            { body: '{ "foo": "bar" }' }
+          );
+
+          it('has proper real type', () => {
+            assert.propertyVal(res, 'realType', 'application/json');
+          });
+        });
+
+        describe('and the bodies do not match', () => {
+          const res = validateBody(
+            { body: '{ "foo": "bar" }' },
+            { body: '{ "bar": null }' }
+          );
+
+          it('has proper real type', () => {
+            assert.propertyVal(res, 'realType', 'application/json');
+          });
+        });
+      });
+    });
+  });
+});

lib/api/units/validateBody.js

@@ -0,0 +1,77 @@
+const jph = require('json-parse-helpfulerror');
+const mediaTyper = require('media-typer');
+const contentTypeUtils = require('content-type');
+
+/**
+ * Determines if a given content type header contains JSON.
+ * @param {string} contentType
+ * @returns {boolean}
+ */
+function isJsonContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+
+  try {
+    const { type } = contentTypeUtils.parse(`${contentType}`);
+    const parsed = mediaTyper.parse(type);
+    return (
+      (parsed.type === 'application' && parsed.subtype === 'json') ||
+      parsed.suffix === 'json'
+    );
+  } catch (error) {
+    // The Content-Type value is basically a user input, it can be any
+    // kind of rubbish, and it is neither this function's nor Gavel's problem
+    // if it's invalid
+    return false;
+  }
+}
+
+/**
+ * Validates given bodies of transaction elements.
+ * @param {Object} real
+ * @param {Object} expected
+ */
+function validateBody(real, expected) {
+  const { headers: realHeaders, body: realBody } = real;
+  const { body: expectedBody } = expected;
+  const bodyType = typeof realBody;
+  const contentType = realHeaders && realHeaders['content-type'];
+  const hasJsonContentType = isJsonContentType(contentType);
+  let realType = null;
+  const results = [];
+
+  console.log(expectedBody);
+
+  if (bodyType !== 'string') {
+    throw new Error(`Expected HTTP body to be a String, but got: ${bodyType}`);
+  }
+
+  try {
+    jph.parse(realBody);
+    realType = hasJsonContentType ? contentType : 'application/json';
+  } catch (error) {
+    realType = 'text/plain';
+
+    if (hasJsonContentType) {
+      results.push({
+        message: `\
+Real body 'Content-Type' header is '${contentType}' \
+but body is not a parseable JSON:
+${error.message}\
+        `,
+        severity: 'error'
+      });
+    }
+  }
+
+  return {
+    validator: null,
+    realType,
+    expectedType: null,
+    rawData: null,
+    results
+  };
+}
+
+module.exports = validateBody;