Decouple middleware handling logic into separate class

src/services/request/PromiseMiddlewareLayer.js

@@ -0,0 +1,48 @@
+/**
+ * A class to handle middleware layer
+ */
+export default class PromiseMiddlewareLayer {
+    /**
+     * @private
+     */
+    middlewares = [];
+
+    /**
+     * Adds middleware into layer.
+     *
+     * `middleware` is an object, that may have multiple keys of type function.
+     * Each key is a name of an action that may be passed through the layer. Each
+     * function should return a Promise. An action with name catch has a special
+     * meaning: it will be invoked as catch callback on Promise (for middlewares,
+     * that should handle errors)
+     *
+     * @param {object} middleware
+     */
+    add(middleware) {
+        if (typeof middleware !== 'object') {
+            throw new Error('A middleware must be an object');
+        }
+
+        if (!this.middlewares.some((mdware) => mdware === middleware)) {
+            this.middlewares.push(middleware);
+        }
+    }
+
+    /**
+     * @param {string} action - the name of middleware's hook
+     * @param {object} data - the initial data to pass through middlewares chain
+     * @param {function} restart - a function to restart current request (for `catch` hook)
+     *
+     * @return {Promise}
+     */
+    run(action, data, restart) {
+        const promiseMethod = action === 'catch' ? 'catch' : 'then';
+
+        return this.middlewares
+            .filter((middleware) => middleware[action])
+            .reduce(
+                (promise, middleware) => promise[promiseMethod]((resp) => middleware[action](resp, restart)),
+                Promise[action === 'catch' ? 'reject' : 'resolve'](data)
+            );
+    }
+}

src/services/request/request.js

@@ -1,4 +1,6 @@
-const middlewares = [];
+import PromiseMiddlewareLayer from './PromiseMiddlewareLayer';
+
+const middlewareLayer = new PromiseMiddlewareLayer();
 
 export default {
     /**
@@ -54,9 +56,7 @@ export default {
      *                                        return a Promise that resolves to the new response.
      */
     addMiddleware(middleware) {
-        if (!middlewares.some((mdware) => mdware === middleware)) {
-            middlewares.push(middleware);
-        }
+        middlewareLayer.add(middleware);
     }
 };
 
@@ -73,32 +73,16 @@ function doFetch(url, options = {}) {
     options.headers = options.headers || {};
     options.headers.Accept = 'application/json';
 
-    return runMiddlewares('before', {url, options})
+    return middlewareLayer.run('before', {url, options})
         .then(({url, options}) => fetch(url, options))
         .then(checkStatus)
         .then(toJSON, rejectWithJSON)
         .then(handleResponseSuccess)
-        .then((resp) => runMiddlewares('then', resp))
-        .catch((resp) => runMiddlewares('catch', resp, () => doFetch(url, options)))
+        .then((resp) => middlewareLayer.run('then', resp))
+        .catch((resp) => middlewareLayer.run('catch', resp, () => doFetch(url, options)))
         ;
 }
 
-/**
- * @param {string} action - the name of middleware's hook (before|then|catch)
- * @param {object} data - the initial data to pass through middlewares chain
- * @param {function} restart - a function to restart current request (for `catch` hook)
- *
- * @return {Promise}
- */
-function runMiddlewares(action, data, restart) {
-    return middlewares
-        .filter((middleware) => middleware[action])
-        .reduce(
-            (promise, middleware) => promise[/^catch|then$/.test(action) ? action : 'then']((resp) => middleware[action](resp, restart)),
-            Promise[action === 'catch' ? 'reject' : 'resolve'](data)
-        );
-}
-
 /**
  * Converts specific js values to query friendly values
  *

tests/services/request/PromiseMiddlewareLayer.test.js

@@ -0,0 +1,137 @@
+import expect from 'unexpected';
+
+import PromiseMiddlewareLayer from 'services/request/PromiseMiddlewareLayer';
+
+describe('PromiseMiddlewareLayer', () => {
+    describe('#add()', () => {
+        let layer;
+
+        beforeEach(() => {
+            layer = new PromiseMiddlewareLayer();
+        });
+
+        it('should have no middlewares by default', () => {
+            expect(layer.middlewares, 'to have length', 0);
+        });
+
+        it('should add middleware into layer', () => {
+            layer.add({});
+
+            expect(layer.middlewares, 'to have length', 1);
+        });
+
+        it('throws if middleware is not object', () => {
+            expect(() => layer.add(1), 'to throw', 'A middleware must be an object');
+        });
+    });
+
+    describe('#run()', () => {
+        it('should return promise', () => {
+            const layer = new PromiseMiddlewareLayer();
+
+            expect(layer.run('then'), 'to be a', Promise);
+        });
+
+        testAction('then');
+        testAction('catch');
+
+        function testAction(name) {
+            describe(`run('${name}')`, () => {
+                it('should run middleware', () => {
+                    const layer = new PromiseMiddlewareLayer();
+                    const middleware = {
+                        [name]: sinon.spy(() => Promise.resolve()).named(`middleware.${name}`)
+                    };
+
+                    layer.add(middleware);
+
+                    return layer.run(name).then(() => {
+                        expect(middleware[name], 'was called once');
+                    });
+                });
+
+                it('should pass data', () => {
+                    const layer = new PromiseMiddlewareLayer();
+                    const middleware = {
+                        [name]: sinon.spy(() => Promise.resolve()).named(`middleware.${name}`)
+                    };
+                    const data = {};
+
+                    layer.add(middleware);
+
+                    return layer.run(name, data).then(() => {
+                        expect(middleware[name], 'to have a call satisfying', [data, undefined]);
+                    });
+                });
+
+                it('should call multiple middlewares', () => {
+                    const layer = new PromiseMiddlewareLayer();
+                    const firstMethod = name === 'catch' ? 'reject' : 'resolve';
+                    const middleware1 = {
+                        [name]: sinon.spy(() => Promise[firstMethod]('new data')).named(`middleware1.${name}`)
+                    };
+                    const middleware2 = {
+                        [name]: sinon.spy(() => Promise.resolve('the last data')).named(`middleware2.${name}`)
+                    };
+
+                    layer.add(middleware1);
+                    layer.add(middleware2);
+
+                    return layer.run(name).then((resp) => {
+                        expect(middleware1[name], 'was called');
+                        expect(middleware2[name], 'to have a call satisfying', ['new data', undefined]);
+                        expect(resp, 'to equal', 'the last data');
+                    });
+                });
+            });
+        }
+
+        it('should not call wrong actions', () => {
+            const layer = new PromiseMiddlewareLayer();
+            const middleware = {
+                then: () => {},
+                wrongAction: sinon.spy(() => Promise.resolve()).named('middleware.wrongAction')
+            };
+
+            layer.add(middleware);
+
+            return layer.run('then').then(() => {
+                expect(middleware.wrongAction, 'was not called');
+            });
+        });
+
+        it('should not call next catch middleware if previous was resolved', () => {
+            const layer = new PromiseMiddlewareLayer();
+            const middleware1 = {
+                catch: () => Promise.resolve()
+            };
+            const middleware2 = {
+                catch: sinon.spy(() => {}).named('middleware2.catch')
+            };
+
+            layer.add(middleware1);
+            layer.add(middleware2);
+
+            return layer.run('catch').then(() => {
+                expect(middleware2.catch, 'was not called');
+            });
+        });
+
+        it('should pass restart callback if any', () => {
+            const layer = new PromiseMiddlewareLayer();
+            const middleware = {
+                catch: sinon.spy(() => Promise.resolve()).named('middleware.catch')
+            };
+            const callback = () => {};
+
+            layer.add(middleware);
+
+            return layer.run('catch', {}, callback).then(() => {
+                expect(middleware.catch, 'to have a call satisfying', [
+                    {},
+                    expect.it('to be', callback)
+                ]);
+            });
+        });
+    });
+});