test(applyMiddleware): added coverage

Author: TimeRaider

package.json

@@ -64,9 +64,11 @@
     "cz-conventional-changelog": "^1.2.0",
     "eslint": "^3.7.1",
     "eslint-plugin-ava": "^4.0.0",
+    "fetch-mock": "^5.5.0",
     "husky": "^0.11.9",
     "nyc": "^9.0.1",
     "rimraf": "^2.5.4",
+    "sinon": "^1.17.6",
     "validate-commit-msg": "^2.8.2"
   },
   "ava": {
@@ -85,6 +87,19 @@
     ],
     "babel": "inherit"
   },
+  "nyc": {
+    "include": [
+      "src/**/*.js"
+    ],
+    "exclude": [
+      "src/**/*spec.js"
+    ],
+    "reporter": [
+      "html",
+      "text",
+      "text-summary"
+    ]
+  },
   "config": {
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"

src/error.js

@@ -6,7 +6,7 @@ function APIError(code, message) {
 Object.setPrototypeOf(APIError.prototype, Error.prototype);
 APIError.prototype.name = 'APIError';
 APIError.prototype.toString = function toString() {
-    return this.code + ' - ' + this.message;
+    return this.message ? this.code + ' - ' + this.message : String(this.code);
 };
 
 export default APIError;

test/applyMiddlewate.spec.js

@@ -0,0 +1,82 @@
+import test from 'ava';
+import sinon from 'sinon';
+import applyMiddleware from '../src/applyMiddleware';
+
+test('applyTo is required', t => {
+    t.throws(() => applyMiddleware());
+});
+
+test('applyTo is not a function', t => {
+    const applyTo = 'oops';
+    t.throws(() => applyMiddleware(applyTo));
+});
+
+test('no middleware returns default params', t => {
+    const applyTo = a => a;
+    const spyApplyTo = sinon.spy(applyTo);
+
+    t.deepEqual(applyMiddleware(spyApplyTo), {});
+    t.true(spyApplyTo.calledOnce);
+    t.true(spyApplyTo.calledWithExactly({}));
+});
+
+test('no functional middleware returns default params', t => {
+    const applyTo = sinon.spy(a => a);
+    const middlewares = [
+        'test', undefined, {}, [], 123, null, NaN, /^/
+    ];
+
+    t.deepEqual(applyMiddleware(applyTo, middlewares), {});
+    t.true(applyTo.calledOnce);
+    t.true(applyTo.calledWithExactly({}));
+});
+
+test('one middleware', t => {
+    const applyTo = sinon.spy(a => a);
+    const middleware = sinon.spy(a => a);
+
+    const options = { options: 'options' };
+    const params = { params: 'params' };
+    const resourceId = 'resourceId';
+    const method = 'method';
+
+    t.deepEqual(applyMiddleware(applyTo, [ middleware ], options, params, resourceId, method), params);
+    t.true(applyTo.calledOnce);
+    t.true(applyTo.calledWithExactly(params, options, params, resourceId, method));
+    t.true(middleware.calledOnce);
+
+    const middlewareSpyCall = middleware.getCall(0);
+    t.true(middlewareSpyCall.args.length === 1);
+    t.true(middlewareSpyCall.args[0] instanceof Function);
+    t.falsy(middlewareSpyCall.thisValue);
+    t.true(middlewareSpyCall.args[0].prototype === undefined);
+});
+
+test('multiple middlewares', t => {
+    const applyTo = sinon.spy(a => a);
+    const middleware1 = sinon.spy(a => a);
+    const middleware2 = sinon.spy(a => a);
+
+    const options = { options: 'options' };
+    const params = { params: 'params' };
+    const resourceId = 'resourceId';
+    const method = 'method';
+
+    t.deepEqual(applyMiddleware(applyTo, [ middleware1, middleware2 ], options, params, resourceId, method), params);
+    t.true(applyTo.calledOnce);
+    t.true(applyTo.calledWithExactly(params, options, params, resourceId, method, options, params, resourceId, method));
+    t.true(middleware1.calledOnce);
+    t.true(middleware2.calledOnce);
+
+    const middleware1SpyCall = middleware1.getCall(0);
+    t.true(middleware1SpyCall.args.length === 1);
+    t.true(middleware1SpyCall.args[0] instanceof Function);
+    t.falsy(middleware1SpyCall.thisValue);
+    t.true(middleware1SpyCall.args[0].prototype === undefined);
+
+    const middleware2SpyCall = middleware2.getCall(0);
+    t.true(middleware2SpyCall.args.length === 1);
+    t.true(middleware2SpyCall.args[0] instanceof Function);
+    t.falsy(middleware2SpyCall.thisValue);
+    t.true(middleware2SpyCall.args[0].prototype === undefined);
+});

test/error.spec.js

@@ -3,6 +3,7 @@ import APIError from '../src/error';
 
 test.beforeEach(t => {
     t.context.error = new APIError(404, 'Not Found');
+    t.context.errorNoMessage = new APIError(404);
 });
 
 test('instance of Error', t => {
@@ -14,5 +15,6 @@ test('instance of APIError', t => {
 });
 
 test('to string', t => {
-    t.is(t.context.error.toString(), '404 - Not Found')
+    t.is(t.context.error.toString(), '404 - Not Found', 'has message');
+    t.is(t.context.errorNoMessage.toString(), '404', 'No message');
 });