1 // cf http://redux.js.org/docs/recipes/WritingTests.html |
1 // cf http://redux.js.org/docs/recipes/WritingTests.html |
2 |
2 |
3 import Immutable from 'immutable'; |
|
4 |
|
5 import uuidV1 from 'uuid/v1'; |
3 import uuidV1 from 'uuid/v1'; |
6 |
4 import * as R from 'ramda'; |
7 import reducer from '../notesReducer' |
5 |
8 import * as types from '../../constants/ActionTypes' |
6 import reducer from '../notesReducer'; |
9 import noteRecord from '../../store/noteRecord'; |
7 import * as types from '../../constants/ActionTypes'; |
|
8 import NoteRecord from '../../store/noteRecord'; |
|
9 import { ActionEnum } from '../../constants'; |
10 |
10 |
11 describe('note reducer', () => { |
11 describe('note reducer', () => { |
12 it('should return the initial state', () => { |
12 it('should return the initial state', () => { |
13 expect( |
13 expect( |
14 reducer(undefined, {}) |
14 reducer(undefined, {}) |
15 ).toEqual(Immutable.List([])) |
15 ).toEqual([]) |
16 }); |
16 }); |
17 |
17 |
18 it('should handle ADD_NOTE', () => { |
18 it('should handle ADD_NOTE', () => { |
19 |
19 |
20 const newId = uuidV1(); |
20 const newId = uuidV1(); |
21 expect( |
21 expect( |
22 reducer(Immutable.List([]), { |
22 reducer([], { |
23 type: types.ADD_NOTE, |
23 type: types.ADD_NOTE, |
24 note: { |
24 note: { |
25 id: newId, |
25 _id: newId, |
26 text: 'Run the tests' |
26 plain: 'Run the tests' |
27 } |
27 } |
28 }) |
28 }) |
29 ).toEqual( |
29 ).toEqual( |
30 Immutable.List([ |
30 [ |
31 new noteRecord({ |
31 NoteRecord({ |
32 id: newId, |
32 _id: newId, |
33 text: 'Run the tests', |
33 plain: 'Run the tests', |
34 }) |
34 }) |
35 ]) |
35 ] |
36 ); |
36 ); |
37 |
37 |
38 const initialStore = Immutable.List([ |
38 const initialStore = [ |
39 new noteRecord({ |
39 NoteRecord({ |
40 id: uuidV1(), |
40 _id: uuidV1(), |
41 text: 'origial note', |
41 plain: 'original note', |
42 }) |
42 }) |
43 ]); |
43 ]; |
44 expect( |
44 expect( |
45 reducer(initialStore, { |
45 reducer(initialStore, { |
46 type: types.ADD_NOTE, |
46 type: types.ADD_NOTE, |
47 note: { |
47 note: { |
48 id: newId, |
48 _id: newId, |
49 text: 'Run the tests' |
49 plain: 'Run the tests' |
50 } |
50 } |
51 }) |
51 }) |
52 ).toEqual( |
52 ).toEqual( |
53 initialStore.push( |
53 R.append(NoteRecord({ |
54 new noteRecord({ |
54 _id: newId, |
55 id: newId, |
55 plain: 'Run the tests', |
56 text: 'Run the tests', |
56 }),initialStore) |
|
57 ); |
|
58 |
|
59 }); |
|
60 |
|
61 it("Handle DELETE_NOTE", () => { |
|
62 |
|
63 const initialStore = [ |
|
64 NoteRecord({ |
|
65 _id: "id1", |
|
66 plain: 'original note', |
|
67 }), |
|
68 NoteRecord({ |
|
69 _id: "id2", |
|
70 plain: 'original note 2', |
|
71 }), |
|
72 NoteRecord({ |
|
73 _id: "id3", |
|
74 plain: 'original note 3', |
|
75 }), |
|
76 ]; |
|
77 |
|
78 expect( |
|
79 reducer(initialStore, { |
|
80 type: types.DELETE_NOTE, |
|
81 note: { |
|
82 _id: "id1", |
|
83 } |
|
84 }) |
|
85 ).toEqual( |
|
86 [ |
|
87 NoteRecord({ |
|
88 _id: "id1", |
|
89 plain: 'original note', |
|
90 action: ActionEnum.DELETED |
|
91 }), |
|
92 NoteRecord({ |
|
93 _id: "id2", |
|
94 plain: 'original note 2', |
|
95 }), |
|
96 NoteRecord({ |
|
97 _id: "id3", |
|
98 plain: 'original note 3', |
|
99 }), |
|
100 ] |
|
101 ); |
|
102 |
|
103 expect( |
|
104 reducer(initialStore, { |
|
105 type: types.DELETE_NOTE, |
|
106 note: { |
|
107 _id: "id0", |
|
108 } |
|
109 }) |
|
110 ).toEqual(initialStore); |
|
111 |
|
112 expect( |
|
113 reducer([], { |
|
114 type: types.DELETE_NOTE, |
|
115 note: { |
|
116 _id: "id0", |
|
117 } |
|
118 }) |
|
119 ).toEqual([]); |
|
120 |
|
121 }); |
|
122 |
|
123 |
|
124 it("Handle DO_DELETE_NOTE", () => { |
|
125 |
|
126 const initialStore = [ |
|
127 NoteRecord({ |
|
128 _id: "id1", |
|
129 plain: 'original note', |
|
130 }), |
|
131 NoteRecord({ |
|
132 _id: "id2", |
|
133 plain: 'original note 2', |
|
134 }), |
|
135 NoteRecord({ |
|
136 _id: "id3", |
|
137 plain: 'original note 3', |
|
138 }), |
|
139 ]; |
|
140 |
|
141 expect( |
|
142 reducer(initialStore, { |
|
143 type: types.DO_DELETE_NOTE, |
|
144 noteId: "id1" |
|
145 }) |
|
146 ).toEqual( |
|
147 [ |
|
148 NoteRecord({ |
|
149 _id: "id2", |
|
150 plain: 'original note 2', |
|
151 }), |
|
152 NoteRecord({ |
|
153 _id: "id3", |
|
154 plain: 'original note 3', |
|
155 }), |
|
156 ] |
|
157 ); |
|
158 |
|
159 expect( |
|
160 reducer(initialStore, { |
|
161 type: types.DO_DELETE_NOTE, |
|
162 noteId: "id0" |
|
163 }) |
|
164 ).toEqual(initialStore); |
|
165 |
|
166 expect( |
|
167 reducer([], { |
|
168 type: types.DO_DELETE_NOTE, |
|
169 noteId: "id0" |
|
170 }) |
|
171 ).toEqual([]); |
|
172 |
|
173 }); |
|
174 |
|
175 |
|
176 it("Handle UPDATE_NOTE", () => { |
|
177 const initialStore = [ |
|
178 NoteRecord({ |
|
179 _id: "id1", |
|
180 plain: 'original note 1', |
|
181 }), |
|
182 NoteRecord({ |
|
183 _id: "id2", |
|
184 plain: 'original note 2', |
|
185 action: ActionEnum.CREATED |
|
186 }), |
|
187 NoteRecord({ |
|
188 _id: "id3", |
|
189 plain: 'original note 3', |
|
190 action: ActionEnum.DELETED |
|
191 }), |
|
192 ]; |
|
193 |
|
194 expect( |
|
195 reducer(initialStore, { |
|
196 type: types.UPDATE_NOTE, |
|
197 note: NoteRecord({ |
|
198 _id: "id1", |
|
199 plain: 'original note 1', |
|
200 action: ActionEnum.None |
|
201 }), |
|
202 data: { |
|
203 plain: 'new note 1' |
|
204 } |
|
205 }) |
|
206 ).toEqual( |
|
207 [ |
|
208 NoteRecord({ |
|
209 _id: "id1", |
|
210 plain: 'new note 1', |
|
211 action: ActionEnum.UPDATED |
|
212 }), |
|
213 NoteRecord({ |
|
214 _id: "id2", |
|
215 plain: 'original note 2', |
|
216 action: ActionEnum.CREATED |
|
217 }), |
|
218 NoteRecord({ |
|
219 _id: "id3", |
|
220 plain: 'original note 3', |
|
221 action: ActionEnum.DELETED |
|
222 }), |
|
223 ] |
|
224 ); |
|
225 |
|
226 expect( |
|
227 reducer(initialStore, { |
|
228 type: types.UPDATE_NOTE, |
|
229 note: NoteRecord({ |
|
230 _id: "id2", |
|
231 }), |
|
232 data: { |
|
233 plain: 'new note 2' |
|
234 } |
|
235 }) |
|
236 ).toEqual( |
|
237 [ |
|
238 NoteRecord({ |
|
239 _id: "id1", |
|
240 plain: 'original note 1' |
|
241 }), |
|
242 NoteRecord({ |
|
243 _id: "id2", |
|
244 plain: 'new note 2', |
|
245 action: ActionEnum.CREATED |
|
246 }), |
|
247 NoteRecord({ |
|
248 _id: "id3", |
|
249 plain: 'original note 3', |
|
250 action: ActionEnum.DELETED |
|
251 }), |
|
252 ] |
|
253 ); |
|
254 |
|
255 expect( |
|
256 reducer(initialStore, { |
|
257 type: types.UPDATE_NOTE, |
|
258 note: NoteRecord({ |
|
259 _id: "id3", |
|
260 }), |
|
261 data: { |
|
262 plain: 'new note 3' |
|
263 } |
|
264 }) |
|
265 ).toEqual( |
|
266 [ |
|
267 NoteRecord({ |
|
268 _id: "id1", |
|
269 plain: 'original note 1' |
|
270 }), |
|
271 NoteRecord({ |
|
272 _id: "id2", |
|
273 plain: 'original note 2', |
|
274 action: ActionEnum.CREATED |
|
275 }), |
|
276 NoteRecord({ |
|
277 _id: "id3", |
|
278 plain: 'new note 3', |
|
279 action: ActionEnum.DELETED |
|
280 }), |
|
281 ] |
|
282 ); |
|
283 |
|
284 expect( |
|
285 reducer(initialStore, { |
|
286 type: types.UPDATE_NOTE, |
|
287 note: { |
|
288 _id: "id0", |
|
289 plain: 'new note 0', |
|
290 } |
|
291 }) |
|
292 ).toEqual(initialStore); |
|
293 |
|
294 expect( |
|
295 reducer([], { |
|
296 type: types.UPDATE_NOTE, |
|
297 note: { |
|
298 _id: "id0", |
|
299 } |
|
300 }) |
|
301 ).toEqual([]); |
|
302 |
|
303 }); |
|
304 |
|
305 |
|
306 |
|
307 it("Handle DELETE_SESSION", () => { |
|
308 const initialStore = [ |
|
309 NoteRecord({ |
|
310 _id: "id1", |
|
311 plain: 'original note 1', |
|
312 session: "session1" |
|
313 }), |
|
314 NoteRecord({ |
|
315 _id: "id2", |
|
316 plain: 'original note 2', |
|
317 session: "session1" |
|
318 }), |
|
319 NoteRecord({ |
|
320 _id: "id3", |
|
321 plain: 'original note 3', |
|
322 session: "session2" |
|
323 }), |
|
324 ]; |
|
325 |
|
326 expect( |
|
327 reducer(initialStore, { |
|
328 type: types.DELETE_SESSION, |
|
329 session: { |
|
330 _id: "session1", |
|
331 } |
|
332 }) |
|
333 ).toEqual( |
|
334 [ |
|
335 NoteRecord({ |
|
336 _id: "id1", |
|
337 plain: 'original note 1', |
|
338 session: "session1", |
|
339 action: ActionEnum.DELETED |
|
340 }), |
|
341 NoteRecord({ |
|
342 _id: "id2", |
|
343 plain: 'original note 2', |
|
344 session: "session1", |
|
345 action: ActionEnum.DELETED |
|
346 }), |
|
347 NoteRecord({ |
|
348 _id: "id3", |
|
349 plain: 'original note 3', |
|
350 session: "session2" |
|
351 }), |
|
352 ] |
|
353 ); |
|
354 |
|
355 expect( |
|
356 reducer(initialStore, { |
|
357 type: types.DELETE_SESSION, |
|
358 session: { |
|
359 _id: "session0", |
|
360 } |
|
361 }) |
|
362 ).toEqual(initialStore); |
|
363 |
|
364 expect( |
|
365 reducer([], { |
|
366 type: types.DELETE_SESSION, |
|
367 session: { |
|
368 _id: "session0", |
|
369 } |
|
370 }) |
|
371 ).toEqual([]); |
|
372 |
|
373 }); |
|
374 |
|
375 |
|
376 it("Handle DO_DELETE_SESSION", () => { |
|
377 const initialStore = [ |
|
378 NoteRecord({ |
|
379 _id: "id1", |
|
380 plain: 'original note 1', |
|
381 session: "session1" |
|
382 }), |
|
383 NoteRecord({ |
|
384 _id: "id2", |
|
385 plain: 'original note 2', |
|
386 session: "session1" |
|
387 }), |
|
388 NoteRecord({ |
|
389 _id: "id3", |
|
390 plain: 'original note 3', |
|
391 session: "session2" |
|
392 }), |
|
393 ]; |
|
394 |
|
395 expect( |
|
396 reducer(initialStore, { |
|
397 type: types.DO_DELETE_SESSION, |
|
398 sessionId: "session1" |
|
399 }) |
|
400 ).toEqual( |
|
401 [ |
|
402 NoteRecord({ |
|
403 _id: "id3", |
|
404 plain: 'original note 3', |
|
405 session: "session2" |
|
406 }), |
|
407 ] |
|
408 ); |
|
409 |
|
410 expect( |
|
411 reducer(initialStore, { |
|
412 type: types.DO_DELETE_SESSION, |
|
413 sessionId: "session0" |
|
414 }) |
|
415 ).toEqual(initialStore); |
|
416 |
|
417 expect( |
|
418 reducer([], { |
|
419 type: types.DO_DELETE_SESSION, |
|
420 sessionId: "session0" |
|
421 }) |
|
422 ).toEqual([]); |
|
423 |
|
424 }); |
|
425 |
|
426 |
|
427 /// |
|
428 /// Handle RESET_ACTION_NOTE |
|
429 /// |
|
430 it("Handle RESET_ACTION_NOTE", () => { |
|
431 |
|
432 const initialStore = [ |
|
433 NoteRecord({ |
|
434 _id: "id1", |
|
435 plain: 'original note 1', |
|
436 action: ActionEnum.UPDATED |
|
437 }), |
|
438 NoteRecord({ |
|
439 _id: "id2", |
|
440 plain: 'original note 2', |
|
441 action: ActionEnum.UPDATED |
|
442 }), |
|
443 NoteRecord({ |
|
444 _id: "id3", |
|
445 plain: 'original note 3', |
|
446 action: ActionEnum.UPDATED |
|
447 }), |
|
448 ]; |
|
449 |
|
450 expect( |
|
451 reducer(initialStore, { |
|
452 type: types.RESET_ACTION_NOTE, |
|
453 note: { |
|
454 _id: "id1", |
|
455 } |
|
456 }) |
|
457 ).toEqual( |
|
458 [ |
|
459 NoteRecord({ |
|
460 _id: "id1", |
|
461 plain: 'original note 1', |
|
462 action: ActionEnum.NONE |
|
463 }), |
|
464 NoteRecord({ |
|
465 _id: "id2", |
|
466 plain: 'original note 2', |
|
467 action: ActionEnum.UPDATED |
|
468 }), |
|
469 NoteRecord({ |
|
470 _id: "id3", |
|
471 plain: 'original note 3', |
|
472 action: ActionEnum.UPDATED |
|
473 }), |
|
474 ] |
|
475 ); |
|
476 |
|
477 expect( |
|
478 reducer(initialStore, { |
|
479 type: types.RESET_ACTION_NOTE, |
|
480 note: { |
|
481 _id: "id0", |
|
482 } |
|
483 }) |
|
484 ).toEqual(initialStore); |
|
485 |
|
486 expect( |
|
487 reducer([], { |
|
488 type: types.RESET_ACTION_NOTE, |
|
489 note: { |
|
490 _id: "id0", |
|
491 } |
|
492 }) |
|
493 ).toEqual([]); |
|
494 |
|
495 }); |
|
496 |
|
497 it("Handle SYNC_RESET_ALL", () => { |
|
498 |
|
499 const initialStore = [ |
|
500 NoteRecord({ |
|
501 _id: "id1", |
|
502 plain: 'original note 1', |
|
503 action: ActionEnum.UPDATED |
|
504 }), |
|
505 NoteRecord({ |
|
506 _id: "id2", |
|
507 plain: 'original note 2', |
|
508 action: ActionEnum.UPDATED |
|
509 }), |
|
510 NoteRecord({ |
|
511 _id: "id3", |
|
512 plain: 'original note 3', |
|
513 action: ActionEnum.UPDATED |
|
514 }), |
|
515 ]; |
|
516 |
|
517 expect( |
|
518 reducer(initialStore, { |
|
519 type: types.SYNC_RESET_ALL, |
|
520 }) |
|
521 ).toEqual( |
|
522 [ |
|
523 NoteRecord({ |
|
524 _id: "id1", |
|
525 plain: 'original note 1', |
|
526 action: ActionEnum.NONE |
|
527 }), |
|
528 NoteRecord({ |
|
529 _id: "id2", |
|
530 plain: 'original note 2', |
|
531 action: ActionEnum.NONE |
|
532 }), |
|
533 NoteRecord({ |
|
534 _id: "id3", |
|
535 plain: 'original note 3', |
|
536 action: ActionEnum.NONE |
|
537 }), |
|
538 ] |
|
539 ); |
|
540 |
|
541 expect( |
|
542 reducer([], { |
|
543 type: types.SYNC_RESET_ALL, |
|
544 }) |
|
545 ).toEqual([]); |
|
546 |
|
547 }); |
|
548 |
|
549 it("Handle LOAD_NOTE", () => { |
|
550 expect( |
|
551 reducer([], { |
|
552 type: types.LOAD_NOTE, |
|
553 note: NoteRecord({ |
|
554 _id: 'note1', |
|
555 plain: 'Run the tests' |
57 }) |
556 }) |
58 ) |
557 }) |
59 ); |
558 ).toEqual( |
60 |
559 [ |
61 }); |
560 NoteRecord({ |
62 |
561 _id: 'note1', |
63 |
562 plain: 'Run the tests', |
|
563 }) |
|
564 ] |
|
565 ); |
|
566 |
|
567 const initialStore = [ |
|
568 NoteRecord({ |
|
569 _id: 'note1', |
|
570 plain: 'original note 1', |
|
571 }), |
|
572 NoteRecord({ |
|
573 _id: 'note2', |
|
574 plain: 'original note 2', |
|
575 }) |
|
576 |
|
577 ]; |
|
578 expect( |
|
579 reducer(initialStore, { |
|
580 type: types.LOAD_NOTE, |
|
581 note: NoteRecord({ |
|
582 _id: 'note1', |
|
583 plain: 'Run the tests' |
|
584 }) |
|
585 }) |
|
586 ).toEqual( |
|
587 [ |
|
588 NoteRecord({ |
|
589 _id: 'note1', |
|
590 plain: 'Run the tests', |
|
591 }), |
|
592 NoteRecord({ |
|
593 _id: 'note2', |
|
594 plain: 'original note 2', |
|
595 }) |
|
596 ] |
|
597 ); |
|
598 |
|
599 expect( |
|
600 reducer(initialStore, { |
|
601 type: types.LOAD_NOTE, |
|
602 note: NoteRecord({ |
|
603 _id: 'note3', |
|
604 plain: 'Run the tests' |
|
605 }) |
|
606 }) |
|
607 ).toEqual( |
|
608 [ |
|
609 NoteRecord({ |
|
610 _id: 'note1', |
|
611 plain: 'original note 1', |
|
612 }), |
|
613 NoteRecord({ |
|
614 _id: 'note2', |
|
615 plain: 'original note 2', |
|
616 }), |
|
617 NoteRecord({ |
|
618 _id: 'note3', |
|
619 plain: 'Run the tests' |
|
620 }) |
|
621 ] |
|
622 ); |
|
623 |
|
624 }); |
|
625 |
|
626 it("Handle AUTH_LOGOUT", () => { |
|
627 const initialStore = [ |
|
628 NoteRecord({ |
|
629 _id: "id1", |
|
630 plain: 'original note 1', |
|
631 action: ActionEnum.UPDATED |
|
632 }), |
|
633 NoteRecord({ |
|
634 _id: "id2", |
|
635 plain: 'original note 2', |
|
636 action: ActionEnum.UPDATED |
|
637 }), |
|
638 NoteRecord({ |
|
639 _id: "id3", |
|
640 plain: 'original note 3', |
|
641 action: ActionEnum.UPDATED |
|
642 }), |
|
643 ]; |
|
644 |
|
645 expect( |
|
646 reducer(initialStore, { |
|
647 type: types.AUTH_LOGOUT, |
|
648 }) |
|
649 ).toEqual( |
|
650 [] |
|
651 ); |
|
652 |
|
653 expect( |
|
654 reducer([], { |
|
655 type: types.AUTH_LOGOUT, |
|
656 }) |
|
657 ).toEqual([]); |
|
658 |
|
659 }); |
64 |
660 |
65 }); |
661 }); |
66 |
662 |
67 // expect( |
663 // expect( |
68 // reducer( |
664 // reducer( |