From fda0e6fc04be8b43de728a519b983a8f72425ab8 Mon Sep 17 00:00:00 2001 From: Ricardo Marques Date: Sun, 8 Apr 2018 15:27:41 -0500 Subject: [PATCH] finish designing spec --- .../__spec/applyMiddleware.spec.js | 35 ++++++++++ .../__spec/callMiddlware.spec.js | 63 ++++++++++++++++++ src/PromiseMiddleware/__spec/execute.spec.js | 12 ++-- src/PromiseMiddleware/__spec/index.spec.js | 1 - src/PromiseMiddleware/__spec/onEvent.spec.js | 64 +++++++++++++++++++ src/PromiseMiddleware/index.js | 4 +- 6 files changed, 171 insertions(+), 8 deletions(-) create mode 100644 src/PromiseMiddleware/__spec/applyMiddleware.spec.js create mode 100644 src/PromiseMiddleware/__spec/callMiddlware.spec.js create mode 100644 src/PromiseMiddleware/__spec/onEvent.spec.js diff --git a/src/PromiseMiddleware/__spec/applyMiddleware.spec.js b/src/PromiseMiddleware/__spec/applyMiddleware.spec.js new file mode 100644 index 0000000..81c707e --- /dev/null +++ b/src/PromiseMiddleware/__spec/applyMiddleware.spec.js @@ -0,0 +1,35 @@ +import Promise from 'promise' +import PromiseMiddleware from '../index' + +describe('applyMiddleware', () => { + const fetcher = () => new Promise(() => {}) + + let MyWrappedFetcher + beforeAll(() => { + MyWrappedFetcher = new PromiseMiddleware(fetcher) + }) + + describe('applyOnRequestMiddleware', () => { + it('adds onRequestMiddleware', () => { + const middleware = () => {} + MyWrappedFetcher.applyOnRequestMiddleware(middleware) + expect(MyWrappedFetcher._middleware.onRequest).toEqual([middleware]) + }) + }) + + describe('applyOnSuccessMiddleware', () => { + it('adds onSuccessMiddleware', () => { + const middleware = () => {} + MyWrappedFetcher.applyOnSuccessMiddleware(middleware) + expect(MyWrappedFetcher._middleware.onSuccess).toEqual([middleware]) + }) + }) + + describe('applyOnErrorMiddleware', () => { + it('adds onErrorMiddleware', () => { + const middleware = () => {} + MyWrappedFetcher.applyOnErrorMiddleware(middleware) + expect(MyWrappedFetcher._middleware.onError).toEqual([middleware]) + }) + }) +}) diff --git a/src/PromiseMiddleware/__spec/callMiddlware.spec.js b/src/PromiseMiddleware/__spec/callMiddlware.spec.js new file mode 100644 index 0000000..9502bc4 --- /dev/null +++ b/src/PromiseMiddleware/__spec/callMiddlware.spec.js @@ -0,0 +1,63 @@ +import Promise from 'promise' +import sinon, { assert } from 'sinon' + +import PromiseMiddleware from '../index' + + +describe('callMiddlware', () => { + const sandbox = sinon.sandbox.create() + const fetcher = () => new Promise(() => {}) + let MyWrappedFetcher + + beforeAll(() => { + MyWrappedFetcher = new PromiseMiddleware(fetcher) + }) + + afterEach(() => { + sandbox.restore() + }) + + it('returns a finished state object if no middleware is given', () => { + expect(MyWrappedFetcher._callMiddleware([])).toEqual({ finished: true }) + }) + + it('calls the first middleware, giving the eventProperties and a "stop" cb', () => { + const eventProperties = {} + const middleware = [sandbox.stub().callsFake((eventProperties, stop) => { + expect(eventProperties).toEqual(eventProperties) + expect(stop).toBeInstanceOf(Function) + })] + + MyWrappedFetcher._callMiddleware(middleware, eventProperties) + assert.calledOnce(middleware[0]) + }) + + it('stops middleware execution if any of the middleware call "stop"', () => { + const middlewareThatWillBeCalled = [sandbox.spy(), sandbox.spy()] + const middlewareThatWillNotBeCalled = [sandbox.spy(), sandbox.spy()] + const middlewareThatStopsExecution = (eventProperties, stop) => { + stop() + } + + const middleware = [...middlewareThatWillBeCalled, middlewareThatStopsExecution, ...middlewareThatWillNotBeCalled] + + MyWrappedFetcher._callMiddleware(middleware) + + middlewareThatWillBeCalled.forEach(middleware => { + assert.calledOnce(middleware) + }) + + middlewareThatWillNotBeCalled.forEach(middleware => { + assert.notCalled(middleware) + }) + }) + + it('returns a stopped status if any middlware call "stop"', () => { + const middlewareThatStopsExecution = (eventProperties, stop) => { + stop() + } + + const result = MyWrappedFetcher._callMiddleware([middlewareThatStopsExecution]) + expect(result).toEqual({ wasStopped: true }) + }) +}) diff --git a/src/PromiseMiddleware/__spec/execute.spec.js b/src/PromiseMiddleware/__spec/execute.spec.js index df6e889..5d8eee4 100644 --- a/src/PromiseMiddleware/__spec/execute.spec.js +++ b/src/PromiseMiddleware/__spec/execute.spec.js @@ -18,11 +18,15 @@ describe('execute', () => { }) it('calls _onRequest, giving the arguments, a setResponse and a setError function', () => { - sandbox.spy(MyWrappedFetcher, '_onRequest') let args = [] + sandbox.stub(MyWrappedFetcher, '_onRequest').callsFake(({ args, setResponse, setError }) => { + expect(args).toEqual(args) + expect(setResponse).toBeInstanceOf(Function) + expect(setError).toBeInstanceOf(Function) + return {} + }) MyWrappedFetcher.execute(...args) assert.calledOnce(MyWrappedFetcher._onRequest) - assert.calledWith(MyWrappedFetcher._onRequest, match({ args })) }) describe('if setResponse is called', () => { @@ -53,9 +57,7 @@ describe('execute', () => { it('does not execute the action', () => { sandbox.spy(MyWrappedFetcher, '_action') - MyWrappedFetcher.execute(...args) - assert.notCalled(MyWrappedFetcher._action) }) }) @@ -88,9 +90,7 @@ describe('execute', () => { it('does not execute the action', () => { sandbox.spy(MyWrappedFetcher, '_action') - MyWrappedFetcher.execute(...args) - assert.notCalled(MyWrappedFetcher._action) }) }) diff --git a/src/PromiseMiddleware/__spec/index.spec.js b/src/PromiseMiddleware/__spec/index.spec.js index 670d1e0..4dd91b0 100644 --- a/src/PromiseMiddleware/__spec/index.spec.js +++ b/src/PromiseMiddleware/__spec/index.spec.js @@ -1,7 +1,6 @@ import Promise from 'promise' import PromiseMiddleware from '../index' - describe('PromiseMiddlware', () => { const fetcher = () => new Promise(() => {}) diff --git a/src/PromiseMiddleware/__spec/onEvent.spec.js b/src/PromiseMiddleware/__spec/onEvent.spec.js new file mode 100644 index 0000000..586fb41 --- /dev/null +++ b/src/PromiseMiddleware/__spec/onEvent.spec.js @@ -0,0 +1,64 @@ +import Promise from 'promise' +import sinon, { assert } from 'sinon' + +import PromiseMiddleware from '../index' + + +describe('onEvent', () => { + const sandbox = sinon.sandbox.create() + const fetcher = () => new Promise(() => {}) + let MyWrappedFetcher + + beforeAll(() => { + MyWrappedFetcher = new PromiseMiddleware(fetcher) + }) + + afterEach(() => { + sandbox.restore() + }) + + describe('onRequest', () => { + it('runs onRequest middlware passing in the event properties', () => { + sandbox.spy(MyWrappedFetcher, '_callMiddleware') + + const middleware = () => {} + MyWrappedFetcher._middleware.onRequest = [middleware] + + const eventProperties = {} + MyWrappedFetcher._onRequest(eventProperties) + + assert.calledOnce(MyWrappedFetcher._callMiddleware) + assert.calledWith(MyWrappedFetcher._callMiddleware, [middleware], eventProperties) + }) + }) + + describe('onSuccess', () => { + it('runs onSuccess middlware passing in the event properties', () => { + sandbox.spy(MyWrappedFetcher, '_callMiddleware') + + const middleware = () => {} + MyWrappedFetcher._middleware.onSuccess = [middleware] + + const eventProperties = {} + MyWrappedFetcher._onSuccess(eventProperties) + + assert.calledOnce(MyWrappedFetcher._callMiddleware) + assert.calledWith(MyWrappedFetcher._callMiddleware, [middleware], eventProperties) + }) + }) + + describe('onError', () => { + it('runs onError middlware passing in the event properties', () => { + sandbox.spy(MyWrappedFetcher, '_callMiddleware') + + const middleware = () => {} + MyWrappedFetcher._middleware.onError = [middleware] + + const eventProperties = {} + MyWrappedFetcher._onError(eventProperties) + + assert.calledOnce(MyWrappedFetcher._callMiddleware) + assert.calledWith(MyWrappedFetcher._callMiddleware, [middleware], eventProperties) + }) + }) +}) diff --git a/src/PromiseMiddleware/index.js b/src/PromiseMiddleware/index.js index e0ec242..8b3a81d 100644 --- a/src/PromiseMiddleware/index.js +++ b/src/PromiseMiddleware/index.js @@ -97,7 +97,7 @@ export default class PromiseMiddleware { } _callMiddleware (middleware: ?Array<*>, eventProperties: *) { - if (!middleware || middleware.length === 0) { + if (middleware == null || middleware.length === 0) { return { finished: true } } @@ -112,6 +112,8 @@ export default class PromiseMiddleware { if (wasStopped) { return { wasStopped: true } + } else if (restMiddleware.length === 0) { + return { finished: true } } else { return this._callMiddleware(restMiddleware, eventProperties) }