spy-middleware
v1.2.2
Published
a redux middleware for spying actions
Downloads
443
Maintainers
Readme
spyMiddleware
Middleware that spyies all actions and allows you to wait for specific actions or events.
Quick Use
Install with npm:
npm install spy-middleware
or for just testing:
npm install -D spy-middleware
Use in your code:
import { createStore, applyMiddleware } from 'redux'
import makeSpyMiddleware from 'spy-middleware'
import { fetchTopic, PUT_TOPIC } from '../actions'
import middleware from '../middleware'
import reducer from '../reducer'
import { getTopic } from '../selectors'
let spyMiddleware
let store
beforeEach(() => {
spyMiddleware = makeSpyMiddleware()
store = createStore(reducer, applyMiddleware(middleware, spyMiddleware))
})
test("when a fetchTopic is requested it retrieves the topic from the REST service", async () => {
fetch.mockResponse('This is the readme')
store.dispatch(fetchTopic('README'))
await spyMiddleware.untilNext(PUT_TOPIC)
const topic = getTopic(store.getState(), { name: 'README' })
expect(topic).toEqual('This is the readme')
})
makeSpyMiddleware()
It creates a middleware compatible with redux applyMiddleware that contains specific methods to spy what is happening inside the store.
import makeSpyMiddleware from 'spy-middleware'
let spyMiddleware
beforeEach(() => {
spyMiddleware = makeSpyMiddleware()
})
spyMiddleware
Redux middleware that has to be applied with applyMiddleware
let store
beforeEach(() => {
store = createStore(reducer, applyMiddleware(spyMiddleware))
})
### spyMiddleware.getActions(): Action[]
Get all dispatched and reduced actions.
store.dispatch(startAction)
store.dispatch(stopAction)
store.dispatch(resumeAction)
const actions = spyMiddleware.getActions()
expect(actions).toEqual([startAction, stopAction, resumeAction])
### spyMiddleware.getAction(string|regExp|(action)=>bool): Action
Get the last action that satisfies the condition or undefined if none.
store.dispatch(startAction)
store.dispatch(stopAction)
store.dispatch(resumeAction)
const foundAction = spyMiddleware.getAction(/^S/i)
expect(foundAction).toBe(stopAction)
### spyMiddleware.untilNext(string|regExp|(action)=>bool): Promise
Returns a promise which is resolved when the matching action is dispatched and reduced.
let actionsBeforeAwait
let actionsAfterAwait
delay(1).then(() => store.dispatch(startAction))
actionsBeforeAwait = spyMiddleware.getActions()
await spyMiddleware.untilNext(START)
actionsAfterAwait = spyMiddleware.getActions()
expect(actionsBeforeAwait).toEqual([])
expect(actionsAfterAwait).toEqual([startAction])
The promise is resolved with the first action
fired after untilNext
call
that satisfies the condition.
delay(1).then(() => store.dispatch(startAction))
const foundStartAction = await spyMiddleware.untilNext(START)
expect(foundStartAction).toBe(startAction)
### spyMiddleware.until(string|regExp|(action)=>bool): Promise
Returns a promise which is resolved when the matching action is dispatched and reduced or if a matching action was resolved in the past.
let actionFoundByUntil
let actionFoundByUntilNext
store.dispatch(startAction)
const untilFinished = spyMiddleware.until(action => {
if (/^S/.test(action.type)) {
actionFoundByUntil = action
return true
}
return false
})
const untilNextFinished = spyMiddleware.untilNext(action => {
if (/^S/.test(action.type)) {
actionFoundByUntilNext = action
return true
}
return false
})
store.dispatch(stopAction)
await untilFinished
await untilNextFinished
expect(actionFoundByUntil).toBe(startAction)
expect(actionFoundByUntilNext).toBe(stopAction)
The promise is resolved with the first action ever dispatched that satisfies the condition.
store.dispatch(startAction)
const foundStartAction = await spyMiddleware.untilNext(START)
expect(foundStartAction).toBe(startAction)
### ### spyMiddleware.clearActions(): void
Clears the list of dispatched actions.
store.dispatch(startAction)
store.dispatch(stopAction)
spyMiddleware.clearActions()
store.dispatch(resumeAction)
const actions = spyMiddleware.getActions()
expect(actions).toEqual([resumeAction])