finish designing spec

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])
+    })
+  })
+})

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 })
+  })
+})

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)
     })
   })

src/PromiseMiddleware/__spec/index.spec.js

@@ -1,7 +1,6 @@
 import Promise from 'promise'
 import PromiseMiddleware from '../index'
 
-
 describe('PromiseMiddlware', () => {
   const fetcher = () => new Promise(() => {})
 

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)
+    })
+  })
+})

src/PromiseMiddleware/index.js

@@ -97,7 +97,7 @@ export default class PromiseMiddleware<T: Action> {
   }
 
   _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<T: Action> {
 
     if (wasStopped) {
       return { wasStopped: true }
+    } else if (restMiddleware.length === 0) {
+      return { finished: true }
     } else {
       return this._callMiddleware(restMiddleware, eventProperties)
     }