source: frontend/node_modules/bfj/test/unit/parse.js

Last change on this file was 9af201e, checked in by MBK <marija.karapandzova@…>, 2 weeks ago

Fix frontend appearance
  • Property mode set to 100644
File size: 34.4 KB
Line 
1'use strict'
2
3const assert = require('chai').assert
4const proxyquire = require('proxyquire')
5const spooks = require('spooks')
6const Promise = require('bluebird')
7
8const modulePath = '../../src/parse'
9
10suite('parse:', () => {
11 test('require does not throw', () => {
12 assert.doesNotThrow(() => {
13 require(modulePath)
14 })
15 })
16
17 test('require returns function', () => {
18 assert.isFunction(require(modulePath))
19 })
20
21 suite('require:', () => {
22 let log, results, parse
23
24 setup(() => {
25 log = {}
26 results = {
27 walk: [
28 {
29 on: spooks.fn({ name: 'on', log: log }),
30 pause: spooks.fn({ name: 'pause', log: log, results: [ () => {} ] }),
31 removeAllListeners: spooks.fn({ name: 'removeAllListeners', log: log })
32 }
33 ]
34 }
35 parse = proxyquire(modulePath, {
36 './walk': spooks.fn({
37 name: 'walk',
38 log: log,
39 results: results.walk
40 })
41 })
42 })
43
44 test('parse expects one argument', () => {
45 assert.lengthOf(parse, 1)
46 })
47
48 test('parse does not throw', () => {
49 assert.doesNotThrow(() => {
50 parse()
51 })
52 })
53
54 test('parse does not throw if reviver is an object', () => {
55 assert.doesNotThrow(() => {
56 parse({}, { reviver: {} }).catch(() => {})
57 })
58 })
59
60 test('parse does not throw if revive is a function', () => {
61 assert.doesNotThrow(() => {
62 parse({}, { reviver: () => {} })
63 })
64 })
65
66 test('parse returns a promise', () => {
67 assert.instanceOf(parse(), Promise)
68 })
69
70 test('parse returns a different type of promise if the option is set', () => {
71 assert.isFunction(global.Promise)
72 assert.notStrictEqual(Promise, global.Promise)
73 assert.instanceOf(parse('', { Promise: global.Promise }), global.Promise)
74 })
75
76 test('parse rejects immediately if reviver is an object', () => {
77 return parse({}, { reviver: {} })
78 .then(() => assert(false))
79 .catch(error => assert.instanceOf(error, Error))
80 })
81
82 test('parse does not reject immediately if reviver is a function', () => {
83 parse({}, { reviver: () => {} })
84 .catch(error => assert(false))
85 })
86
87 test('walk was not called', () => {
88 assert.strictEqual(log.counts.walk, 0)
89 })
90
91 test('EventEmitter.on was not called', () => {
92 assert.strictEqual(log.counts.on, 0)
93 })
94
95 suite('parse:', () => {
96 let stream, options
97
98 setup(() => {
99 stream = {}
100 options = {}
101 parse(stream, options)
102 .then(spooks.fn({ name: 'resolve', log: log }))
103 .catch(spooks.fn({ name: 'reject', log: log }))
104 })
105
106 test('walk was called once', () => {
107 assert.strictEqual(log.counts.walk, 1)
108 assert.isUndefined(log.these.walk[0])
109 })
110
111 test('walk was called correctly', () => {
112 assert.lengthOf(log.args.walk[0], 2)
113 assert.strictEqual(log.args.walk[0][0], stream)
114 assert.lengthOf(Object.keys(log.args.walk[0][0]), 0)
115 assert.strictEqual(log.args.walk[0][1], options)
116 assert.lengthOf(Object.keys(log.args.walk[0][1]), 0)
117 })
118
119 test('EventEmitter.on was called eleven times', () => {
120 assert.strictEqual(log.counts.on, 11)
121 assert.strictEqual(log.these.on[0], results.walk[0])
122 assert.strictEqual(log.these.on[1], results.walk[0])
123 assert.strictEqual(log.these.on[2], results.walk[0])
124 assert.strictEqual(log.these.on[3], results.walk[0])
125 assert.strictEqual(log.these.on[4], results.walk[0])
126 assert.strictEqual(log.these.on[5], results.walk[0])
127 assert.strictEqual(log.these.on[6], results.walk[0])
128 assert.strictEqual(log.these.on[7], results.walk[0])
129 assert.strictEqual(log.these.on[8], results.walk[0])
130 assert.strictEqual(log.these.on[9], results.walk[0])
131 assert.strictEqual(log.these.on[10], results.walk[0])
132 })
133
134 test('EventEmitter.on was called correctly first time', () => {
135 assert.lengthOf(log.args.on[0], 2)
136 assert.strictEqual(log.args.on[0][0], 'arr')
137 assert.isFunction(log.args.on[0][1])
138 })
139
140 test('EventEmitter.on was called correctly second time', () => {
141 assert.lengthOf(log.args.on[1], 2)
142 assert.strictEqual(log.args.on[1][0], 'obj')
143 assert.isFunction(log.args.on[1][1])
144 assert.notStrictEqual(log.args.on[1][1], log.args.on[0][1])
145 })
146
147 test('EventEmitter.on was called correctly third time', () => {
148 assert.lengthOf(log.args.on[2], 2)
149 assert.strictEqual(log.args.on[2][0], 'pro')
150 assert.isFunction(log.args.on[2][1])
151 assert.notStrictEqual(log.args.on[2][1], log.args.on[0][1])
152 assert.notStrictEqual(log.args.on[2][1], log.args.on[1][1])
153 })
154
155 test('EventEmitter.on was called correctly fourth time', () => {
156 assert.lengthOf(log.args.on[3], 2)
157 assert.strictEqual(log.args.on[3][0], 'str')
158 assert.isFunction(log.args.on[3][1])
159 assert.notStrictEqual(log.args.on[3][1], log.args.on[0][1])
160 assert.notStrictEqual(log.args.on[3][1], log.args.on[1][1])
161 assert.notStrictEqual(log.args.on[3][1], log.args.on[2][1])
162 })
163
164 test('EventEmitter.on was called correctly fifth time', () => {
165 assert.lengthOf(log.args.on[4], 2)
166 assert.strictEqual(log.args.on[4][0], 'num')
167 assert.isFunction(log.args.on[4][1])
168 assert.strictEqual(log.args.on[4][1], log.args.on[3][1])
169 })
170
171 test('EventEmitter.on was called correctly sixth time', () => {
172 assert.lengthOf(log.args.on[5], 2)
173 assert.strictEqual(log.args.on[5][0], 'lit')
174 assert.isFunction(log.args.on[5][1])
175 assert.strictEqual(log.args.on[5][1], log.args.on[3][1])
176 })
177
178 test('EventEmitter.on was called correctly seventh time', () => {
179 assert.lengthOf(log.args.on[6], 2)
180 assert.strictEqual(log.args.on[6][0], 'end-arr')
181 assert.isFunction(log.args.on[6][1])
182 assert.notStrictEqual(log.args.on[6][1], log.args.on[0][1])
183 assert.notStrictEqual(log.args.on[6][1], log.args.on[1][1])
184 assert.notStrictEqual(log.args.on[6][1], log.args.on[2][1])
185 assert.notStrictEqual(log.args.on[6][1], log.args.on[3][1])
186 })
187
188 test('EventEmitter.on was called correctly eighth time', () => {
189 assert.lengthOf(log.args.on[7], 2)
190 assert.strictEqual(log.args.on[7][0], 'end-obj')
191 assert.isFunction(log.args.on[7][1])
192 assert.strictEqual(log.args.on[7][1], log.args.on[6][1])
193 })
194
195 test('EventEmitter.on was called correctly ninth time', () => {
196 assert.lengthOf(log.args.on[8], 2)
197 assert.strictEqual(log.args.on[8][0], 'end')
198 assert.isFunction(log.args.on[8][1])
199 assert.notStrictEqual(log.args.on[8][1], log.args.on[0][1])
200 assert.notStrictEqual(log.args.on[8][1], log.args.on[1][1])
201 assert.notStrictEqual(log.args.on[8][1], log.args.on[2][1])
202 assert.notStrictEqual(log.args.on[8][1], log.args.on[3][1])
203 assert.notStrictEqual(log.args.on[8][1], log.args.on[6][1])
204 })
205
206 test('EventEmitter.on was called correctly tenth time', () => {
207 assert.lengthOf(log.args.on[9], 2)
208 assert.strictEqual(log.args.on[9][0], 'err')
209 assert.isFunction(log.args.on[9][1])
210 assert.notStrictEqual(log.args.on[9][1], log.args.on[0][1])
211 assert.notStrictEqual(log.args.on[9][1], log.args.on[1][1])
212 assert.notStrictEqual(log.args.on[9][1], log.args.on[2][1])
213 assert.notStrictEqual(log.args.on[9][1], log.args.on[3][1])
214 assert.notStrictEqual(log.args.on[9][1], log.args.on[6][1])
215 assert.notStrictEqual(log.args.on[9][1], log.args.on[8][1])
216 })
217
218 test('EventEmitter.on was called correctly eleventh time', () => {
219 assert.lengthOf(log.args.on[10], 2)
220 assert.strictEqual(log.args.on[10][0], 'err-data')
221 assert.isFunction(log.args.on[10][1])
222 assert.strictEqual(log.args.on[10][1], log.args.on[9][1])
223 })
224
225 suite('array event:', () => {
226 setup(() => {
227 log.args.on[0][1]()
228 })
229
230 test('resolve was not called', () => {
231 assert.strictEqual(log.counts.resolve, 0)
232 })
233
234 suite('end event:', () => {
235 setup(done => {
236 log.args.on[8][1]()
237 setImmediate(done)
238 })
239
240 test('resolve was called once', () => {
241 assert.strictEqual(log.counts.resolve, 1)
242 })
243
244 test('resolve was called correctly', () => {
245 assert.isUndefined(log.these.resolve[0])
246 assert.lengthOf(log.args.resolve[0], 1)
247 assert.isArray(log.args.resolve[0][0])
248 assert.lengthOf(log.args.resolve[0][0], 0)
249 })
250
251 test('reject was not called', () => {
252 assert.strictEqual(log.counts.reject, 0)
253 })
254 })
255
256 suite('string event:', () => {
257 setup(() => {
258 log.args.on[3][1]('foo')
259 })
260
261 test('resolve was not called', () => {
262 assert.strictEqual(log.counts.resolve, 0)
263 })
264
265 suite('end event:', () => {
266 setup(done => {
267 log.args.on[8][1]()
268 setImmediate(done)
269 })
270
271 test('resolve was called once', () => {
272 assert.strictEqual(log.counts.resolve, 1)
273 })
274
275 test('resolve was called correctly', () => {
276 assert.lengthOf(log.args.resolve[0], 1)
277 assert.isArray(log.args.resolve[0][0])
278 assert.lengthOf(log.args.resolve[0][0], 1)
279 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
280 })
281 })
282
283 suite('string event:', () => {
284 setup(() => {
285 log.args.on[3][1]('bar')
286 })
287
288 test('resolve was not called', () => {
289 assert.strictEqual(log.counts.resolve, 0)
290 })
291
292 suite('end event:', () => {
293 setup(done => {
294 log.args.on[8][1]()
295 setImmediate(done)
296 })
297
298 test('resolve was called once', () => {
299 assert.strictEqual(log.counts.resolve, 1)
300 })
301
302 test('resolve was called correctly', () => {
303 assert.lengthOf(log.args.resolve[0][0], 2)
304 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
305 assert.strictEqual(log.args.resolve[0][0][1], 'bar')
306 })
307 })
308 })
309
310 suite('array event:', () => {
311 setup(() => {
312 log.args.on[0][1]()
313 })
314
315 test('resolve was not called', () => {
316 assert.strictEqual(log.counts.resolve, 0)
317 })
318
319 suite('end event:', () => {
320 setup(done => {
321 log.args.on[8][1]()
322 setImmediate(done)
323 })
324
325 test('resolve was called once', () => {
326 assert.strictEqual(log.counts.resolve, 1)
327 })
328
329 test('resolve was called correctly', () => {
330 assert.lengthOf(log.args.resolve[0][0], 2)
331 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
332 assert.isArray(log.args.resolve[0][0][1])
333 assert.lengthOf(log.args.resolve[0][0][1], 0)
334 })
335 })
336
337 suite('string event:', () => {
338 setup(() => {
339 log.args.on[3][1]('bar')
340 })
341
342 test('resolve was not called', () => {
343 assert.strictEqual(log.counts.resolve, 0)
344 })
345
346 suite('end event:', () => {
347 setup(done => {
348 log.args.on[8][1]()
349 setImmediate(done)
350 })
351
352 test('resolve was called once', () => {
353 assert.strictEqual(log.counts.resolve, 1)
354 })
355
356 test('resolve was called correctly', () => {
357 assert.lengthOf(log.args.resolve[0][0], 2)
358 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
359 assert.isArray(log.args.resolve[0][0][1])
360 assert.lengthOf(log.args.resolve[0][0][1], 1)
361 assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
362 })
363 })
364
365 suite('string event:', () => {
366 setup(() => {
367 log.args.on[3][1]('baz')
368 })
369
370 test('resolve was not called', () => {
371 assert.strictEqual(log.counts.resolve, 0)
372 })
373
374 suite('end event:', () => {
375 setup(done => {
376 log.args.on[8][1]()
377 setImmediate(done)
378 })
379
380 test('resolve was called once', () => {
381 assert.strictEqual(log.counts.resolve, 1)
382 })
383
384 test('resolve was called correctly', () => {
385 assert.lengthOf(log.args.resolve[0][0], 2)
386 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
387 assert.isArray(log.args.resolve[0][0][1])
388 assert.lengthOf(log.args.resolve[0][0][1], 2)
389 assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
390 assert.strictEqual(log.args.resolve[0][0][1][1], 'baz')
391 })
392 })
393 })
394
395 suite('endArray event:', () => {
396 setup(() => {
397 log.args.on[6][1]()
398 })
399
400 suite('string event:', () => {
401 setup(() => {
402 log.args.on[3][1]('baz')
403 })
404
405 test('resolve was not called', () => {
406 assert.strictEqual(log.counts.resolve, 0)
407 })
408
409 suite('end event:', () => {
410 setup(done => {
411 log.args.on[8][1]()
412 setImmediate(done)
413 })
414
415 test('resolve was called once', () => {
416 assert.strictEqual(log.counts.resolve, 1)
417 })
418
419 test('resolve was called correctly', () => {
420 assert.lengthOf(log.args.resolve[0][0], 3)
421 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
422 assert.isArray(log.args.resolve[0][0][1])
423 assert.lengthOf(log.args.resolve[0][0][1], 1)
424 assert.strictEqual(log.args.resolve[0][0][1][0], 'bar')
425 assert.strictEqual(log.args.resolve[0][0][2], 'baz')
426 })
427 })
428 })
429 })
430 })
431 })
432
433 suite('object event:', () => {
434 setup(() => {
435 log.args.on[1][1]()
436 })
437
438 test('resolve was not called', () => {
439 assert.strictEqual(log.counts.resolve, 0)
440 })
441
442 suite('end event:', () => {
443 setup(done => {
444 log.args.on[8][1]()
445 setImmediate(done)
446 })
447
448 test('resolve was called once', () => {
449 assert.strictEqual(log.counts.resolve, 1)
450 })
451
452 test('resolve was called correctly', () => {
453 assert.lengthOf(log.args.resolve[0][0], 2)
454 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
455 assert.isObject(log.args.resolve[0][0][1])
456 assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 0)
457 })
458 })
459
460 suite('property event:', () => {
461 setup(() => {
462 log.args.on[2][1]('bar')
463 })
464
465 suite('string event:', () => {
466 setup(() => {
467 log.args.on[3][1]('baz')
468 })
469
470 test('resolve was not called', () => {
471 assert.strictEqual(log.counts.resolve, 0)
472 })
473
474 suite('end event:', () => {
475 setup(done => {
476 log.args.on[8][1]()
477 setImmediate(done)
478 })
479
480 test('resolve was called once', () => {
481 assert.strictEqual(log.counts.resolve, 1)
482 })
483
484 test('resolve was called correctly', () => {
485 assert.lengthOf(log.args.resolve[0][0], 2)
486 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
487 assert.isObject(log.args.resolve[0][0][1])
488 assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 1)
489 assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
490 })
491 })
492
493 suite('property event:', () => {
494 setup(() => {
495 log.args.on[2][1]('qux')
496 })
497
498 suite('string event:', () => {
499 setup(() => {
500 log.args.on[3][1]('wibble')
501 })
502
503 test('resolve was not called', () => {
504 assert.strictEqual(log.counts.resolve, 0)
505 })
506
507 suite('end event:', () => {
508 setup(done => {
509 log.args.on[8][1]()
510 setImmediate(done)
511 })
512
513 test('resolve was called once', () => {
514 assert.strictEqual(log.counts.resolve, 1)
515 })
516
517 test('resolve was called correctly', () => {
518 assert.lengthOf(log.args.resolve[0][0], 2)
519 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
520 assert.isObject(log.args.resolve[0][0][1])
521 assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 2)
522 assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
523 assert.strictEqual(log.args.resolve[0][0][1].qux, 'wibble')
524 })
525 })
526 })
527 })
528
529 suite('endObject event:', () => {
530 setup(() => {
531 log.args.on[7][1]()
532 })
533
534 suite('string event:', () => {
535 setup(() => {
536 log.args.on[3][1]('wibble')
537 })
538
539 test('resolve was not called', () => {
540 assert.strictEqual(log.counts.resolve, 0)
541 })
542
543 suite('end event:', () => {
544 setup(done => {
545 log.args.on[8][1]()
546 setImmediate(done)
547 })
548
549 test('resolve was called once', () => {
550 assert.strictEqual(log.counts.resolve, 1)
551 })
552
553 test('resolve was called correctly', () => {
554 assert.lengthOf(log.args.resolve[0][0], 3)
555 assert.strictEqual(log.args.resolve[0][0][0], 'foo')
556 assert.isObject(log.args.resolve[0][0][1])
557 assert.lengthOf(Object.keys(log.args.resolve[0][0][1]), 1)
558 assert.strictEqual(log.args.resolve[0][0][1].bar, 'baz')
559 assert.strictEqual(log.args.resolve[0][0][2], 'wibble')
560 })
561 })
562 })
563 })
564 })
565 })
566 })
567 })
568
569 suite('error event:', () => {
570 setup(() => {
571 log.args.on[9][1]('foo')
572 })
573
574 test('reject was not called', () => {
575 assert.strictEqual(log.counts.reject, 0)
576 })
577
578 suite('end event:', () => {
579 setup(done => {
580 log.args.on[8][1]()
581 setImmediate(done)
582 })
583
584 test('reject was called once', () => {
585 assert.strictEqual(log.counts.reject, 1)
586 })
587
588 test('reject was called correctly', () => {
589 assert.isUndefined(log.these.reject[0])
590 assert.lengthOf(log.args.reject[0], 1)
591 assert.strictEqual(log.args.reject[0][0], 'foo')
592 })
593 })
594
595 suite('error event:', () => {
596 setup(() => {
597 log.args.on[9][1]('bar')
598 })
599
600 test('reject was not called', () => {
601 assert.strictEqual(log.counts.reject, 0)
602 })
603
604 suite('end event:', () => {
605 setup(done => {
606 log.args.on[8][1]()
607 setImmediate(done)
608 })
609
610 test('reject was called once', () => {
611 assert.strictEqual(log.counts.reject, 1)
612 })
613
614 test('reject was called correctly', () => {
615 assert.strictEqual(log.args.reject[0][0], 'foo')
616 })
617 })
618 })
619 })
620 })
621
622 suite('object event:', () => {
623 setup(() => {
624 log.args.on[1][1]()
625 })
626
627 test('resolve was not called', () => {
628 assert.strictEqual(log.counts.resolve, 0)
629 })
630
631 suite('end event:', () => {
632 setup(done => {
633 log.args.on[8][1]()
634 setImmediate(done)
635 })
636
637 test('resolve was called once', () => {
638 assert.strictEqual(log.counts.resolve, 1)
639 })
640
641 test('resolve was called correctly', () => {
642 assert.isObject(log.args.resolve[0][0])
643 assert.lengthOf(Object.keys(log.args.resolve[0][0]), 0)
644 })
645 })
646 })
647 })
648
649 suite('parse with reviver:', () => {
650 let stream, options
651
652 setup(() => {
653 stream = {}
654 options = { reviver: spooks.fn({ name: 'reviver', log: log, results: [ 'reviver result' ] }) }
655 parse(stream, options)
656 .then(spooks.fn({ name: 'resolve', log: log }))
657 .catch(spooks.fn({ name: 'reject', log: log }))
658 })
659
660 test('walk was called once', () => {
661 assert.strictEqual(log.counts.walk, 1)
662 })
663
664 test('EventEmitter.on was called eleven times', () => {
665 assert.strictEqual(log.counts.on, 11)
666 })
667
668 suite('populated array events:', () => {
669 setup(() => {
670 log.args.on[0][1]()
671 log.args.on[3][1]('foo')
672 log.args.on[3][1]('bar')
673 log.args.on[0][1]()
674 log.args.on[0][1]()
675 log.args.on[3][1]('baz')
676 log.args.on[6][1]()
677 log.args.on[3][1]('qux')
678 log.args.on[6][1]()
679 log.args.on[6][1]()
680 })
681
682 test('resolve was not called', () => {
683 assert.strictEqual(log.counts.resolve, 0)
684 })
685
686 test('reviver was not called', () => {
687 assert.strictEqual(log.counts.resolve, 0)
688 })
689
690 suite('end event:', () => {
691 setup(done => {
692 log.args.on[8][1]()
693 setImmediate(done)
694 })
695
696 test('resolve was called once', () => {
697 assert.strictEqual(log.counts.resolve, 1)
698 })
699
700 test('reviver was called six times', () => {
701 assert.strictEqual(log.counts.reviver, 7)
702 })
703
704 test('reviver was called correctly first time', () => {
705 assert.lengthOf(log.args.reviver[0], 2)
706 assert.strictEqual(log.args.reviver[0][0], '0')
707 assert.strictEqual(log.args.reviver[0][1], 'foo')
708 })
709
710 test('reviver was called correctly second time', () => {
711 assert.strictEqual(log.args.reviver[1][0], '1')
712 assert.strictEqual(log.args.reviver[1][1], 'bar')
713 })
714
715 test('reviver was called correctly third time', () => {
716 assert.strictEqual(log.args.reviver[2][0], '0')
717 assert.strictEqual(log.args.reviver[2][1], 'baz')
718 })
719
720 test('reviver was called correctly fourth time', () => {
721 assert.strictEqual(log.args.reviver[3][0], '0')
722 assert.isArray(log.args.reviver[3][1])
723 assert.lengthOf(log.args.reviver[3][1], 1)
724 assert.strictEqual(log.args.reviver[3][1][0], 'reviver result')
725 })
726
727 test('reviver was called correctly fifth time', () => {
728 assert.strictEqual(log.args.reviver[4][0], '1')
729 assert.strictEqual(log.args.reviver[4][1], 'qux')
730 })
731
732 test('reviver was called correctly sixth time', () => {
733 assert.strictEqual(log.args.reviver[5][0], '2')
734 assert.isArray(log.args.reviver[5][1])
735 assert.lengthOf(log.args.reviver[5][1], 2)
736 assert.strictEqual(log.args.reviver[5][1][0], 'reviver result')
737 assert.strictEqual(log.args.reviver[5][1][1], 'reviver result')
738 })
739
740 test('reviver was called correctly seventh time', () => {
741 assert.strictEqual(log.args.reviver[6][0], '')
742 assert.isArray(log.args.reviver[6][1])
743 assert.lengthOf(log.args.reviver[6][1], 3)
744 assert.strictEqual(log.args.reviver[6][1][0], 'reviver result')
745 assert.strictEqual(log.args.reviver[6][1][1], 'reviver result')
746 assert.strictEqual(log.args.reviver[6][1][2], 'reviver result')
747 })
748 })
749 })
750
751 suite('populated object events:', () => {
752 setup(() => {
753 log.args.on[1][1]()
754 log.args.on[2][1]('foo')
755 log.args.on[1][1]()
756 log.args.on[2][1]('bar')
757 log.args.on[4][1](3.14159265359)
758 log.args.on[7][1]()
759 log.args.on[2][1]('baz')
760 log.args.on[5][1](null)
761 log.args.on[7][1]()
762 })
763
764 test('resolve was not called', () => {
765 assert.strictEqual(log.counts.resolve, 0)
766 })
767
768 test('reviver was not called', () => {
769 assert.strictEqual(log.counts.resolve, 0)
770 })
771
772 suite('end event:', () => {
773 setup(done => {
774 log.args.on[8][1]()
775 setImmediate(done)
776 })
777
778 test('resolve was called once', () => {
779 assert.strictEqual(log.counts.resolve, 1)
780 })
781
782 test('reviver was called four times', () => {
783 assert.strictEqual(log.counts.reviver, 4)
784 })
785
786 test('reviver was called correctly first time', () => {
787 assert.lengthOf(log.args.reviver[0], 2)
788 assert.strictEqual(log.args.reviver[0][0], 'bar')
789 assert.strictEqual(log.args.reviver[0][1], 3.14159265359)
790 })
791
792 test('reviver was called correctly second time', () => {
793 assert.strictEqual(log.args.reviver[1][0], 'foo')
794 assert.isObject(log.args.reviver[1][1])
795 assert.lengthOf(Object.keys(log.args.reviver[1][1]), 1)
796 assert.strictEqual(log.args.reviver[1][1].bar, 'reviver result')
797 })
798
799 test('reviver was called correctly third time', () => {
800 assert.strictEqual(log.args.reviver[2][0], 'baz')
801 assert.isNull(log.args.reviver[2][1])
802 })
803
804 test('reviver was called correctly fourth time', () => {
805 assert.strictEqual(log.args.reviver[3][0], '')
806 assert.isObject(log.args.reviver[3][1])
807 assert.lengthOf(Object.keys(log.args.reviver[3][1]), 2)
808 assert.strictEqual(log.args.reviver[3][1].foo, 'reviver result')
809 assert.strictEqual(log.args.reviver[3][1].baz, 'reviver result')
810 })
811 })
812 })
813 })
814
815 suite('parse with ndjson:', () => {
816 let stream
817
818 setup(() => {
819 stream = {}
820 parse(stream, { ndjson: true })
821 .then(spooks.fn({ name: 'resolve', log: log }))
822 .catch(spooks.fn({ name: 'reject', log: log }))
823 })
824
825 test('walk was called once', () => {
826 assert.strictEqual(log.counts.walk, 1)
827 })
828
829 test('EventEmitter.on was called twelve times', () => {
830 assert.strictEqual(log.counts.on, 12)
831 assert.strictEqual(log.these.on[11], results.walk[0])
832 })
833
834 test('EventEmitter.on was called correctly first eleven times', () => {
835 assert.strictEqual(log.args.on[0][0], 'arr')
836 assert.strictEqual(log.args.on[1][0], 'obj')
837 assert.strictEqual(log.args.on[2][0], 'pro')
838 assert.strictEqual(log.args.on[3][0], 'str')
839 assert.strictEqual(log.args.on[4][0], 'num')
840 assert.strictEqual(log.args.on[5][0], 'lit')
841 assert.strictEqual(log.args.on[6][0], 'end-arr')
842 assert.strictEqual(log.args.on[7][0], 'end-obj')
843 assert.strictEqual(log.args.on[8][0], 'end')
844 assert.strictEqual(log.args.on[9][0], 'err')
845 assert.strictEqual(log.args.on[10][0], 'err-data')
846 })
847
848 test('EventEmitter.on was called correctly twelfth time', () => {
849 assert.lengthOf(log.args.on[11], 2)
850 assert.strictEqual(log.args.on[11][0], 'end-line')
851 assert.isFunction(log.args.on[11][1])
852 assert.notStrictEqual(log.args.on[11][1], log.args.on[0][1])
853 assert.notStrictEqual(log.args.on[11][1], log.args.on[1][1])
854 assert.notStrictEqual(log.args.on[11][1], log.args.on[2][1])
855 assert.notStrictEqual(log.args.on[11][1], log.args.on[3][1])
856 assert.notStrictEqual(log.args.on[11][1], log.args.on[6][1])
857 assert.notStrictEqual(log.args.on[11][1], log.args.on[8][1])
858 assert.notStrictEqual(log.args.on[11][1], log.args.on[9][1])
859 })
860
861 test('emitter.pause was not called', () => {
862 assert.strictEqual(log.counts.pause, 0)
863 })
864
865 test('emitter.removeAllListeners was not called', () => {
866 assert.strictEqual(log.counts.removeAllListeners, 0)
867 })
868
869 suite('array, endArray, endLine:', () => {
870 setup(done => {
871 log.args.on[0][1]()
872 log.args.on[6][1]()
873 log.args.on[11][1]()
874 setImmediate(done)
875 })
876
877 test('resolve was called once', () => {
878 assert.strictEqual(log.counts.resolve, 1)
879 })
880
881 test('resolve was called correctly', () => {
882 assert.lengthOf(log.args.resolve[0], 1)
883 assert.isArray(log.args.resolve[0][0])
884 assert.lengthOf(log.args.resolve[0][0], 0)
885 })
886
887 test('emitter.pause was called once', () => {
888 assert.strictEqual(log.counts.pause, 1)
889 })
890
891 test('emitter.pause was called correctly', () => {
892 assert.lengthOf(log.args.pause[0], 0)
893 })
894
895 test('emitter.removeAllListeners was called once', () => {
896 assert.strictEqual(log.counts.removeAllListeners, 1)
897 })
898
899 test('emitter.removeAllListeners was called correctly', () => {
900 assert.lengthOf(log.args.removeAllListeners[0], 0)
901 })
902
903 test('reject was not called', () => {
904 assert.strictEqual(log.counts.reject, 0)
905 })
906
907 suite('parse with ndjson:', () => {
908 setup(() => {
909 parse(stream, { ndjson: true })
910 .then(spooks.fn({ name: 'resolve2', log: log }))
911 .catch(spooks.fn({ name: 'reject2', log: log }))
912 })
913
914 test('EventEmitter.on was called twelve times', () => {
915 assert.strictEqual(log.counts.on, 24)
916 })
917
918 test('walk was not called', () => {
919 assert.strictEqual(log.counts.walk, 1)
920 })
921
922 suite('string, end:', () => {
923 setup(done => {
924 log.args.on[15][1]('foo')
925 log.args.on[20][1]()
926 setImmediate(done)
927 })
928
929 test('resolve was called once', () => {
930 assert.strictEqual(log.counts.resolve, 1)
931 assert.strictEqual(log.counts.resolve2, 1)
932 })
933
934 test('resolve was called correctly', () => {
935 assert.lengthOf(log.args.resolve2[0], 1)
936 assert.strictEqual(log.args.resolve2[0][0], 'foo')
937 })
938
939 test('emitter.pause was called once', () => {
940 assert.strictEqual(log.counts.pause, 2)
941 })
942
943 test('emitter.removeAllListeners was called once', () => {
944 assert.strictEqual(log.counts.removeAllListeners, 2)
945 })
946
947 test('reject was not called', () => {
948 assert.strictEqual(log.counts.reject, 0)
949 assert.strictEqual(log.counts.reject2, 0)
950 })
951
952 suite('parse with ndjson:', () => {
953 setup(() => {
954 parse(stream, { ndjson: true })
955 .then(spooks.fn({ name: 'resolve3', log: log }))
956 .catch(spooks.fn({ name: 'reject3', log: log }))
957 })
958
959 test('EventEmitter.on was called twelve times', () => {
960 assert.strictEqual(log.counts.on, 36)
961 })
962
963 test('walk was not called', () => {
964 assert.strictEqual(log.counts.walk, 1)
965 })
966
967 suite('end:', () => {
968 setup(done => {
969 log.args.on[32][1]()
970 setImmediate(done)
971 })
972
973 test('resolve was called once', () => {
974 assert.strictEqual(log.counts.resolve, 1)
975 assert.strictEqual(log.counts.resolve2, 1)
976 assert.strictEqual(log.counts.resolve3, 1)
977 })
978
979 test('resolve was called correctly', () => {
980 assert.lengthOf(log.args.resolve3[0], 1)
981 assert.strictEqual(log.args.resolve3[0][0], undefined)
982 })
983
984 test('emitter.pause was called once', () => {
985 assert.strictEqual(log.counts.pause, 3)
986 })
987
988 test('emitter.removeAllListeners was called once', () => {
989 assert.strictEqual(log.counts.removeAllListeners, 3)
990 })
991
992 test('reject was not called', () => {
993 assert.strictEqual(log.counts.reject, 0)
994 assert.strictEqual(log.counts.reject2, 0)
995 assert.strictEqual(log.counts.reject3, 0)
996 })
997 })
998 })
999 })
1000 })
1001
1002 suite('parse with ndjson and fresh stream:', () => {
1003 setup(() => {
1004 parse({}, { ndjson: true })
1005 .then(spooks.fn({ name: 'resolve2', log: log }))
1006 .catch(spooks.fn({ name: 'reject2', log: log }))
1007 })
1008
1009 test('EventEmitter.on was called twelve times', () => {
1010 assert.strictEqual(log.counts.on, 24)
1011 })
1012
1013 test('walk was called once', () => {
1014 assert.strictEqual(log.counts.walk, 2)
1015 })
1016 })
1017 })
1018 })
1019 })
1020})
Note: See TracBrowser for help on using the repository browser.