-
-
Notifications
You must be signed in to change notification settings - Fork 2k
/
effectMiddlewares.js
144 lines (118 loc) · 3.49 KB
/
effectMiddlewares.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
import test from 'tape'
import { createStore, applyMiddleware } from 'redux'
import sagaMiddleware from '../../src'
import { call, take, all } from '../../src/effects'
test('effectMiddlewares - single', assert => {
assert.plan(1)
let actual = []
function rootReducer(state = {}, action) {
return action
}
const effectMiddleware = next => effect => {
if (effect === apiCall) {
Promise.resolve().then(() => next('injected value'))
return
}
return next(effect)
}
const middleware = sagaMiddleware({ effectMiddlewares: [effectMiddleware] })
const store = createStore(rootReducer, {}, applyMiddleware(middleware))
const apiCall = call(() => new Promise(() => {}))
function* root() {
actual.push(yield all([call(fnA), apiCall]))
}
function* fnA() {
const result = []
result.push((yield take('ACTION-1')).val)
result.push((yield take('ACTION-2')).val)
return result
}
const task = middleware.run(root)
Promise.resolve()
.then(() => store.dispatch({ type: 'ACTION-1', val: 1 }))
.then(() => store.dispatch({ type: 'ACTION-2', val: 2 }))
const expected = [[[1, 2], 'injected value']]
task
.toPromise()
.then(() => {
assert.deepEqual(
actual,
expected,
'effectMiddleware must be able to intercept and resolve effect in a custom way',
)
})
.catch(err => assert.fail(err))
})
test('effectMiddlewares - multiple', assert => {
assert.plan(1)
let actual = []
function rootReducer(state = {}, action) {
return action
}
const effectMiddleware1 = next => effect => {
actual.push('middleware1 received', effect)
if (effect === apiCall1) {
Promise.resolve().then(() => next('middleware1 injected value'))
return
}
actual.push('middleware1 passed trough', effect)
return next(effect)
}
const effectMiddleware2 = next => effect => {
actual.push('middleware2 received', effect)
if (effect === apiCall2) {
Promise.resolve().then(() => next('middleware2 injected value'))
return
}
actual.push('middleware2 passed trough', effect)
return next(effect)
}
const middleware = sagaMiddleware({ effectMiddlewares: [effectMiddleware1, effectMiddleware2] })
createStore(rootReducer, {}, applyMiddleware(middleware))
const apiCall1 = call(() => new Promise(() => {}))
const apiCall2 = call(() => new Promise(() => {}))
const callA = call(fnA)
function* root() {
actual.push("effect's result is", yield apiCall1)
actual.push("effect's result is", yield callA)
actual.push("effect's result is", yield apiCall2)
}
function* fnA() {
return 'fnA result'
}
const task = middleware.run(root)
const expected = [
'middleware1 received',
apiCall1,
'middleware2 received',
'middleware1 injected value',
'middleware2 passed trough',
'middleware1 injected value',
"effect's result is",
'middleware1 injected value',
'middleware1 received',
callA,
'middleware1 passed trough',
callA,
'middleware2 received',
callA,
'middleware2 passed trough',
callA,
"effect's result is",
'fnA result',
'middleware1 received',
apiCall2,
'middleware1 passed trough',
apiCall2,
'middleware2 received',
apiCall2,
"effect's result is",
'middleware2 injected value',
]
task
.toPromise()
.then(() => {
assert.deepEqual(actual, expected, 'multiple effectMiddlewares must create a chain')
})
.catch(err => assert.fail(err))
})