Debian Codegraph @

closure-library/third_party/closure/goog/mochikit/async/deferred_test.js

raw
1 /**
2 * Copyright 2009 The Closure Library Authors. All Rights Reserved.
3 * Author: [email protected] (Erik Arvidsson)
4 */
5
6 goog.setTestOnly();
7 goog.require('goog.Promise');
8 goog.require('goog.Thenable');
9 goog.require('goog.async.Deferred');
10 goog.require('goog.testing.MockClock');
11 goog.require('goog.testing.PropertyReplacer');
12 goog.require('goog.testing.jsunit');
13 goog.require('goog.testing.recordFunction');
14
15 var Deferred = goog.async.Deferred;
16 var AlreadyCalledError = Deferred.AlreadyCalledError;
17 var CanceledError = Deferred.CanceledError;
18
19 // Unhandled errors may be sent to the browser on a timeout.
20 var mockClock = new goog.testing.MockClock();
21 var stubs = new goog.testing.PropertyReplacer();
22
23 function setUp() {
24 mockClock.install();
25 }
26
27 function tearDown() {
28 // Advance the mockClock to fire any unhandled exception timeouts.
29 mockClock.tick();
30 mockClock.uninstall();
31 stubs.reset();
32 }
33
34 /**
35 * @param {string} msg Message to show upon failure.
36 * @param {T} expected Expected value.
37 * @return {!function(T): T} Function to be called with the actual value that
38 * will assert that it is equal to the expected value.
39 * @template T
40 */
41 function assertEqualsCallback(msg, expected) {
42 return function(res) {
43 assertEquals(msg, expected, res);
44 // Since the assertion is an exception that will be caught inside the
45 // Deferred object, we must advance the clock to see if it has failed.
46 mockClock.tick();
47 return res;
48 };
49 }
50
51 /**
52 * @param {number} res
53 * @return {number}
54 */
55 function increment(res) {
56 return res + 1;
57 }
58
59 /**
60 * @param {*} res
61 */
62 function throwStuff(res) {
63 throw res;
64 }
65
66 /**
67 * @param {*} res
68 * @return {*}
69 */
70 function catchStuff(res) {
71 return res;
72 }
73
74 /**
75 * @param {*} res
76 * @return {!Error}
77 */
78 function returnError(res) {
79 return Error(res);
80 }
81
82 /**
83 * @param {?} res
84 */
85 function neverHappen(res) {
86 fail('This should not happen');
87 }
88
89 function testNormal() {
90 var d = new Deferred();
91 d.addCallback(assertEqualsCallback('pre-deferred callback', 1));
92 d.callback(1);
93 d.addCallback(increment);
94 d.addCallback(assertEqualsCallback('post-deferred callback', 2));
95 d.addCallback(throwStuff);
96 d.addCallback(neverHappen);
97 d.addErrback(catchStuff);
98 d.addCallback(assertEqualsCallback('throw -> err, catch -> success', 2));
99 d.addCallback(returnError);
100 d.addCallback(neverHappen);
101 d.addErrback(catchStuff);
102 d.addCallback(assertEqualsCallback('return -> err, catch -> succcess', 2));
103 }
104
105 function testCancel() {
106 var count = 0;
107 function canceled(d) {
108 count++;
109 }
110
111 function canceledError(res) {
112 assertTrue(res instanceof CanceledError);
113 }
114
115 var d = new Deferred(canceled);
116 d.addCallback(neverHappen);
117 d.addErrback(canceledError);
118 d.cancel();
119
120 assertEquals(1, count);
121 }
122
123 function testSucceedFail() {
124 var count = 0;
125
126 var d = Deferred.succeed(1).addCallback(assertEqualsCallback('succeed', 1));
127
128 // default error
129 d = Deferred.fail().addCallback(neverHappen);
130 d = d.addErrback(function(res) {
131 count++;
132 return res;
133 });
134
135 // default wrapped error
136 d = Deferred.fail('web taco').addCallback(neverHappen).addErrback(catchStuff);
137 d = d.addCallback(assertEqualsCallback('wrapped fail', 'web taco'));
138
139 // default unwrapped error
140 d = Deferred.fail(Error('ugh')).addCallback(neverHappen).addErrback(
141 catchStuff);
142 d = d.addCallback(assertEqualsCallback('unwrapped fail', 'ugh'));
143
144 assertEquals(1, count);
145 }
146
147 function testDeferredDependencies() {
148 function deferredIncrement(res) {
149 var rval = Deferred.succeed(res);
150 rval.addCallback(increment);
151 return rval;
152 }
153
154 var d = Deferred.succeed(1).addCallback(deferredIncrement);
155 d = d.addCallback(assertEqualsCallback('dependent deferred succeed', 2));
156
157 function deferredFailure(res) {
158 return Deferred.fail(res);
159 }
160
161 d = Deferred.succeed('ugh').addCallback(deferredFailure).addErrback(
162 catchStuff);
163 d = d.addCallback(assertEqualsCallback('dependent deferred fail', 'ugh'));
164 }
165
166 // Test double-calling, double-failing, etc.
167 function testDoubleCalling() {
168 var ex = assertThrows(function() {
169 Deferred.succeed(1).callback(2);
170 neverHappen();
171 });
172 assertTrue('double call', ex instanceof AlreadyCalledError);
173 }
174
175 function testDoubleCalling2() {
176 var ex = assertThrows(function() {
177 Deferred.fail(1).errback(2);
178 neverHappen();
179 });
180 assertTrue('double-fail', ex instanceof AlreadyCalledError);
181 }
182
183 function testDoubleCalling3() {
184 var ex = assertThrows(function() {
185 var d = Deferred.succeed(1);
186 d.cancel();
187 d = d.callback(2);
188 assertTrue('swallowed one callback, no canceler', true);
189 d.callback(3);
190 neverHappen();
191 });
192 assertTrue('swallow cancel', ex instanceof AlreadyCalledError);
193 }
194
195 function testDoubleCalling4() {
196 var count = 0;
197 function canceled(d) {
198 count++;
199 }
200
201 var ex = assertThrows(function() {
202 var d = new Deferred(canceled);
203 d.cancel();
204 d = d.callback(1);
205 });
206
207 assertTrue('non-swallowed cancel', ex instanceof AlreadyCalledError);
208 assertEquals(1, count);
209 }
210
211 // Test incorrect Deferred usage
212 function testIncorrectUsage() {
213 var d = new Deferred();
214
215 var ex = assertThrows(function() {
216 d.callback(new Deferred());
217 neverHappen();
218 });
219 assertTrue('deferred not allowed for callback', ex instanceof Error);
220 }
221
222 function testIncorrectUsage2() {
223 var d = new Deferred();
224
225 var ex = assertThrows(function() {
226 d.errback(new Deferred());
227 neverHappen();
228 });
229 assertTrue('deferred not allowed for errback', ex instanceof Error);
230 }
231
232 function testIncorrectUsage3() {
233 var d = new Deferred();
234 (new Deferred()).addCallback(function() {return d;}).callback(1);
235
236 var ex = assertThrows(function() {
237 d.addCallback(function() {});
238 neverHappen();
239 });
240 assertTrue('chained deferred not allowed to be re-used', ex instanceof Error);
241 }
242
243 function testCallbackScope1() {
244 var c1 = {}, c2 = {};
245 var callbackScope = null;
246 var errbackScope = null;
247
248 var d = new Deferred();
249 d.addCallback(function() {
250 callbackScope = this;
251 throw Error('Foo');
252 }, c1);
253 d.addErrback(function() {
254 errbackScope = this;
255 }, c2);
256 d.callback();
257 assertEquals('Incorrect callback scope', c1, callbackScope);
258 assertEquals('Incorrect errback scope', c2, errbackScope);
259 }
260
261 function testCallbackScope2() {
262 var callbackScope = null;
263 var errbackScope = null;
264
265 var d = new Deferred();
266 d.addCallback(function() {
267 callbackScope = this;
268 throw Error('Foo');
269 });
270 d.addErrback(function() {
271 errbackScope = this;
272 });
273 d.callback();
274 assertEquals('Incorrect callback scope', window, callbackScope);
275 assertEquals('Incorrect errback scope', window, errbackScope);
276 }
277
278 function testCallbackScope3() {
279 var c = {};
280 var callbackScope = null;
281 var errbackScope = null;
282
283 var d = new Deferred(null, c);
284 d.addCallback(function() {
285 callbackScope = this;
286 throw Error('Foo');
287 });
288 d.addErrback(function() {
289 errbackScope = this;
290 });
291 d.callback();
292 assertEquals('Incorrect callback scope', c, callbackScope);
293 assertEquals('Incorrect errback scope', c, errbackScope);
294 }
295
296 function testChainedDeferred1() {
297 var calls = [];
298
299 var d2 = new Deferred();
300 d2.addCallback(function() {calls.push('B1');});
301 d2.addCallback(function() {calls.push('B2');});
302
303 var d1 = new Deferred();
304 d1.addCallback(function() {calls.push('A1');});
305 d1.addCallback(function() {calls.push('A2');});
306 d1.chainDeferred(d2);
307 d1.addCallback(function() {calls.push('A3');});
308
309 d1.callback();
310 assertEquals('A1,A2,B1,B2,A3', calls.join(','));
311 }
312
313 function testChainedDeferred2() {
314 var calls = [];
315
316 var d2 = new Deferred();
317 d2.addCallback(function() {calls.push('B1');});
318 d2.addErrback(function(err) {calls.push('B2'); throw Error('x');});
319
320 var d1 = new Deferred();
321 d1.addCallback(function(err) {throw Error('foo');});
322 d1.chainDeferred(d2);
323 d1.addCallback(function() {calls.push('A1');});
324 d1.addErrback(function() {calls.push('A2');});
325
326 d1.callback();
327 assertEquals('B2,A2', calls.join(','));
328
329 var ex = assertThrows(function() {
330 mockClock.tick();
331 neverHappen();
332 });
333 assertTrue('Should catch unhandled throw from d2.', ex.message == 'x');
334 }
335
336 function testUndefinedResultAndCallbackSequence() {
337 var results = [];
338 var d = new Deferred();
339 d.addCallback(function(res) {return 'foo';});
340 d.addCallback(function(res) {results.push(res); return 'bar';});
341 d.addCallback(function(res) {results.push(res);});
342 d.addCallback(function(res) {results.push(res);});
343 d.callback();
344 assertEquals('foo,bar,bar', results.join(','));
345 }
346
347 function testUndefinedResultAndErrbackSequence() {
348 var results = [];
349 var d = new Deferred();
350 d.addCallback(function(res) {throw Error('uh oh');});
351 d.addErrback(function(res) {results.push('A');});
352 d.addCallback(function(res) {results.push('B');});
353 d.addErrback(function(res) {results.push('C');});
354 d.callback();
355 assertEquals('A,C', results.join(','));
356 }
357
358 function testHasFired() {
359 var d1 = new Deferred();
360 var d2 = new Deferred();
361
362 assertFalse(d1.hasFired());
363 assertFalse(d2.hasFired());
364
365 d1.callback();
366 d2.errback();
367 assertTrue(d1.hasFired());
368 assertTrue(d2.hasFired());
369 }
370
371 function testUnhandledErrors() {
372 var d = new Deferred();
373 d.addCallback(throwStuff);
374
375 var ex = assertThrows(function() {
376 d.callback(123);
377 mockClock.tick();
378 neverHappen();
379 });
380 assertEquals('Unhandled throws should hit the browser.', 123, ex);
381
382 assertNotThrows(
383 'Errbacks added after a failure should resume.',
384 function() {
385 d.addErrback(catchStuff);
386 mockClock.tick();
387 });
388
389 d.addCallback(assertEqualsCallback('Should recover after throw.', 1));
390 mockClock.tick();
391 }
392
393 function testStrictUnhandledErrors() {
394 stubs.replace(Deferred, 'STRICT_ERRORS', true);
395 var err = Error('never handled');
396
397 // The registered errback exists, but doesn't modify the error value.
398 var d = Deferred.succeed();
399 d.addCallback(function(res) { throw err; });
400 d.addErrback(function(unhandledErr) {});
401
402 var caught = assertThrows(
403 'The error should be rethrown at the next clock tick.',
404 function() { mockClock.tick(); });
405 assertEquals(err, caught);
406 }
407
408 function testStrictHandledErrors() {
409 stubs.replace(Deferred, 'STRICT_ERRORS', true);
410
411 // The registered errback returns a non-error value.
412 var d = Deferred.succeed();
413 d.addCallback(function(res) { throw Error('eventually handled'); });
414 d.addErrback(function(unhandledErr) { return true; });
415
416 assertNotThrows(
417 'The error was handled and should not be rethrown',
418 function() { mockClock.tick(); });
419 d.addCallback(function(res) { assertTrue(res); });
420 }
421
422 function testStrictBlockedErrors() {
423 stubs.replace(Deferred, 'STRICT_ERRORS', true);
424
425 var d1 = Deferred.fail(Error('blocked failure'));
426 var d2 = new Deferred();
427
428 d1.addBoth(function() { return d2; });
429 assertNotThrows(
430 'd1 should be blocked until d2 fires.',
431 function() { mockClock.tick(); });
432
433 d2.callback('unblocked');
434 d1.addCallback(assertEqualsCallback(
435 'd1 should receive the fired result from d2.', 'unblocked'));
436 }
437
438 function testStrictCanceledErrors() {
439 stubs.replace(Deferred, 'STRICT_ERRORS', true);
440
441 Deferred.canceled();
442 assertNotThrows(
443 'CanceledErrors should not be rethrown to the global scope.',
444 function() { mockClock.tick(); });
445 }
446
447 function testSynchronousErrorCanceling() {
448 var d = new Deferred();
449 d.addCallback(throwStuff);
450
451 assertNotThrows(
452 'Adding an errback to the end of a failing Deferred should cancel the ' +
453 'unhandled error timeout.',
454 function() {
455 d.callback(1);
456 d.addErrback(catchStuff);
457 mockClock.tick();
458 });
459
460 d.addCallback(assertEqualsCallback('Callback should fire', 1));
461 }
462
463 function testThrowNonError() {
464 var results = [];
465
466 var d = new Deferred();
467 d.addCallback(function(res) {
468 throw res;
469 });
470 d.addErrback(function(res) {
471 results.push(res);
472 return 6;
473 });
474 d.addCallback(function(res) {
475 results.push(res);
476 });
477
478 d.callback(7);
479 assertArrayEquals(
480 'Errback should have been called with 7, followed by callback with 6.',
481 [7, 6], results);
482 }
483
484 function testThrownErrorWithNoErrbacks() {
485 var d = new Deferred();
486 d.addCallback(function() {
487 throw Error('foo');
488 });
489 d.addCallback(goog.nullFunction);
490
491 function assertCallback() {
492 d.callback(1);
493 mockClock.tick(); // Should cause error because throwing is delayed.
494 }
495
496 assertThrows('A thrown error should be rethrown if there is no ' +
497 'errback to catch it.', assertCallback);
498 }
499
500 function testThrownErrorCallbacksDoNotCancel() {
501 var d = new Deferred();
502 d.addCallback(function() {
503 throw Error('foo');
504 });
505
506 function assertCallback() {
507 d.callback(1);
508 // Add another callback after the fact. Note this is not an errback!
509 d.addCallback(neverHappen);
510 mockClock.tick(); // Should cause error because throwing is delayed.
511 }
512
513 assertThrows('A thrown error should be rethrown if there is no ' +
514 'errback to catch it.', assertCallback);
515 }
516
517 function testAwaitDeferred() {
518
519 var results = [];
520
521 function fn(x) {
522 return function() {
523 results.push(x);
524 };
525 }
526
527 var d2 = new Deferred();
528 d2.addCallback(fn('b'));
529
530 // d1 -> a -> (wait for d2) -> c
531 var d1 = new Deferred();
532 d1.addCallback(fn('a'));
533 d1.awaitDeferred(d2);
534 d1.addCallback(fn('c'));
535
536 // calls 'a' then yields for d2.
537 d1.callback(null);
538
539 // will get called after d2.
540 d1.addCallback(fn('d'));
541
542 assertEquals('a', results.join(''));
543
544 // d3 -> w -> (wait for d2) -> x
545 var d3 = new Deferred();
546 d3.addCallback(fn('w'));
547 d3.awaitDeferred(d2);
548 d3.addCallback(fn('x'));
549
550 // calls 'w', then yields for d2.
551 d3.callback();
552
553
554 // will get called after d2.
555 d3.addCallback(fn('y'));
556
557 assertEquals('aw', results.join(''));
558
559 // d1 calls 'd', d3 calls 'y'
560 d2.callback(null);
561
562 assertEquals('awbcdxy', results.join(''));
563
564 // d3 and d2 already called, so 'z' called immediately.
565 d3.addCallback(fn('z'));
566
567 assertEquals('awbcdxyz', results.join(''));
568 }
569
570 function testAwaitDeferred_withPromise() {
571
572 var results = [];
573
574 function fn(x) {
575 return function() {
576 results.push(x);
577 };
578 }
579
580 var resolver = new goog.Promise.withResolver();
581 resolver.promise.then(fn('b'));
582
583 // d1 -> a -> (wait for promise) -> c
584 var d1 = new Deferred();
585 d1.addCallback(fn('a'));
586 d1.awaitDeferred(resolver.promise);
587 d1.addCallback(fn('c'));
588
589 // calls 'a' then yields for promise.
590 d1.callback(1);
591
592 // will get called after promise.
593 d1.addCallback(fn('d'));
594
595 assertEquals('a', results.join(''));
596
597 // d3 -> w -> (wait for promise) -> x
598 var d3 = new Deferred();
599 d3.addCallback(fn('w'));
600 d3.awaitDeferred(resolver.promise);
601 d3.addCallback(fn('x'));
602
603 // calls 'w', then yields for promise.
604 d3.callback(2);
605
606
607 // will get called after promise.
608 d3.addCallback(fn('y'));
609
610 assertEquals('aw', results.join(''));
611
612 // d1 calls 'd', d3 calls 'y'
613 resolver.resolve();
614 mockClock.tick();
615
616 assertEquals('awbcdxy', results.join(''));
617
618 // d3 and promise already called, so 'z' called immediately.
619 d3.addCallback(fn('z'));
620
621 assertEquals('awbcdxyz', results.join(''));
622 }
623
624 function testAwaitDeferredWithErrors() {
625 var results = [];
626
627 function fn(x) {
628 return function(e) {
629 results.push(x);
630 };
631 }
632
633 var d2 = new Deferred();
634 d2.addErrback(fn('a'));
635
636 var d1 = new Deferred();
637 d1.awaitDeferred(d2);
638 d1.addCallback(fn('x'));
639 d1.addErrback(fn('b'));
640 d1.callback(null);
641
642 assertEquals('', results.join(''));
643
644 d2.addCallback(fn('z'));
645 d2.addErrback(fn('c'));
646 d2.errback(null);
647
648 // First errback added to d2 prints 'a'.
649 // Next 'd' was chained, so execute its err backs, printing 'b'.
650 // Finally 'c' was added last by d2's errback.
651 assertEquals('abc', results.join(''));
652 }
653
654 function testNonErrorErrback() {
655 var results = [];
656
657 function fn(x) {
658 return function(e) {
659 results.push(x);
660 };
661 }
662
663 var d = new Deferred();
664 d.addCallback(fn('a'));
665 d.addErrback(fn('b'));
666
667 d.addCallback(fn('c'));
668 d.addErrback(fn('d'));
669
670 d.errback('foo');
671
672 assertEquals('bd', results.join(''));
673 }
674
675 function testUnequalReturnValueForErrback() {
676 var results = [];
677
678 function fn(x) {
679 return function(e) {
680 results.push(x);
681 };
682 }
683
684 var d = new Deferred();
685 d.addCallback(fn('a'));
686 d.addErrback(function() {
687 results.push('b');
688 return 'bar';
689 });
690
691 d.addCallback(fn('c'));
692 d.addErrback(fn('d'));
693
694 d.errback('foo');
695
696 assertEquals('bc', results.join(''));
697 }
698
699 function testBranch() {
700 function fn(x) {
701 return function(arr) {
702 return arr.concat(x);
703 };
704 }
705
706 var d = new Deferred();
707 d.addCallback(fn(1));
708 d.addCallback(fn(2));
709 var d2 = d.branch();
710 d.addCallback(fn(3));
711 d2.addCallback(fn(4));
712
713 d.callback([]);
714
715 assertTrue('both deferreds should have fired', d.hasFired());
716 assertTrue('both deferreds should have fired', d2.hasFired());
717 d.addCallback(function(arr) { assertArrayEquals([1, 2, 3], arr); });
718 d2.addCallback(function(arr) { assertArrayEquals([1, 2, 4], arr); });
719 }
720
721 function testDiamondBranch() {
722 function fn(x) {
723 return function(arr) {
724 return arr.concat(x);
725 };
726 }
727
728 var d = new Deferred();
729 d.addCallback(fn(1));
730
731 var d2 = d.branch();
732 d2.addCallback(fn(2));
733
734 // Chain the branch back to the original. There is no good reason to do this
735 // cever.
736 d.addCallback(function(ret) {return d2;});
737 d.callback([]);
738
739 // But no reason it shouldn't work!
740 d.addCallback(function(arr) { assertArrayEquals([1, 2], arr); });
741 }
742
743 function testRepeatedBranch() {
744 var d = new Deferred().addCallback(increment);
745
746 d.branch().
747 addCallback(assertEqualsCallback('branch should be after increment', 2)).
748 addCallback(function(res) {return d.branch();}).
749 addCallback(assertEqualsCallback('second branch should be the same', 2));
750 d.callback(1);
751 }
752
753 function testCancelThroughBranch() {
754 var wasCanceled = false;
755 var d = new Deferred(function() { wasCanceled = true; });
756 var branch1 = d.branch(true);
757 var branch2 = d.branch(true);
758
759 branch1.cancel();
760 assertFalse(wasCanceled);
761 branch2.cancel();
762 assertTrue(wasCanceled);
763 }
764
765 function testCancelThroughSeveralBranches() {
766 var wasCanceled = false;
767 var d = new Deferred(function() { wasCanceled = true; });
768 var branch = d.branch(true).branch(true).branch(true);
769
770 branch.cancel();
771 assertTrue(wasCanceled);
772 }
773
774 function testBranchCancelThenCallback() {
775 var wasCanceled = false;
776 var d = new Deferred(function() { wasCanceled = true; });
777 var wasCalled = false;
778 d.addCallback(function() { wasCalled = true; });
779 var branch1 = d.branch();
780 var branch2 = d.branch();
781
782 var branch1WasCalled = false;
783 var branch2WasCalled = false;
784 branch1.addCallback(function() { branch1WasCalled = true; });
785 branch2.addCallback(function() { branch2WasCalled = true; });
786
787 var branch1HadErrback = false;
788 var branch2HadErrback = false;
789 branch1.addErrback(function() { branch1HadErrback = true; });
790 branch2.addErrback(function() { branch2HadErrback = true; });
791
792 branch1.cancel();
793 assertFalse(wasCanceled);
794 assertTrue(branch1HadErrback);
795 assertFalse(branch2HadErrback);
796
797 d.callback();
798 assertTrue(wasCalled);
799 assertFalse(branch1WasCalled);
800 assertTrue(branch2WasCalled);
801 }
802
803 function testDeepCancelOnBranch() {
804 var wasCanceled = false;
805 var d = new Deferred(function() { wasCanceled = true; });
806 var branch1 = d.branch(true);
807 var branch2 = d.branch(true).branch(true).branch(true);
808
809 var branch1HadErrback = false;
810 var branch2HadErrback = false;
811 branch1.addErrback(function() { branch1HadErrback = true; });
812 branch2.addErrback(function() { branch2HadErrback = true; });
813
814 branch2.cancel(true /* opt_deepCancel */);
815 assertTrue(wasCanceled);
816 assertTrue(branch1HadErrback);
817 assertTrue(branch2HadErrback);
818 }
819
820 function testCancelOnRoot() {
821 var wasCanceled = false;
822 var d = new Deferred(function() { wasCanceled = true; });
823 d.branch(true).branch(true).branch(true);
824
825 d.cancel();
826 assertTrue(wasCanceled);
827 }
828
829 function testCancelOnLeafBranch() {
830 var wasCanceled = false;
831 var branchWasCanceled = false;
832 var d = new Deferred(function() { wasCanceled = true; });
833 var branch = d.branch(true).branch(true).branch(true);
834 branch.addErrback(function() { branchWasCanceled = true; });
835
836 branch.cancel();
837 assertTrue(wasCanceled);
838 assertTrue(branchWasCanceled);
839 }
840
841 function testCancelOnIntermediateBranch() {
842 var rootWasCanceled = false;
843
844 var d = new Deferred(function() { rootWasCanceled = true; });
845 var branch = d.branch(true).branch(true).branch(true);
846
847 var deepBranch1 = branch.branch(true);
848 var deepBranch2 = branch.branch(true);
849
850 branch.cancel();
851 assertTrue(rootWasCanceled);
852 assertTrue(deepBranch1.hasFired());
853 assertTrue(deepBranch2.hasFired());
854 }
855
856 function testCancelWithSomeCompletedBranches() {
857 var d = new Deferred();
858 var branch1 = d.branch(true);
859
860 var branch1HadCallback = false;
861 var branch1HadErrback = false;
862 branch1.
863 addCallback(function() { branch1HadCallback = true; }).
864 addErrback(function() { branch1HadErrback = true; });
865 d.callback(true);
866
867 assertTrue(branch1HadCallback);
868 assertFalse(branch1HadErrback);
869
870 var rootHadCallback = false;
871 var rootHadErrback = false;
872 // Block the root on a new Deferred indefinitely.
873 d.
874 addCallback(function() { rootHadCallback = true; }).
875 addCallback(function() { return new Deferred(); }).
876 addErrback(function() { rootHadErrback = true; });
877 var branch2 = d.branch(true);
878
879 assertTrue(rootHadCallback);
880 assertFalse(rootHadErrback);
881
882 branch2.cancel();
883 assertFalse(branch1HadErrback);
884 assertTrue('Canceling the last active branch should cancel the parent.',
885 rootHadErrback);
886 }
887
888 function testStaticCanceled() {
889 var callbackCalled = false;
890 var errbackResult = null;
891
892 var d = goog.async.Deferred.canceled();
893 d.addCallback(function() { callbackCalled = true;} );
894 d.addErrback(function(err) { errbackResult = err;} );
895
896 assertTrue('Errback should have been called with a canceled error',
897 errbackResult instanceof goog.async.Deferred.CanceledError);
898 assertFalse('Callback should not have been called', callbackCalled);
899 }
900
901 function testWhenWithValues() {
902 var called = false;
903 Deferred.when(4, function(obj) {
904 called = true;
905 assertEquals(4, obj);
906 });
907 assertTrue('Fn should have been called', called);
908 }
909
910 function testWhenWithDeferred() {
911 var called = false;
912
913 var d = new Deferred();
914 Deferred.when(d, function(obj) {
915 called = true;
916 assertEquals(6, obj);
917 });
918 assertFalse('Fn should not have been called yet', called);
919 d.callback(6);
920 assertTrue('Fn should have been called', called);
921 }
922
923 function testWhenDoesntAlterOriginalChain() {
924 var calls = 0;
925
926 var d1 = new Deferred();
927 var d2 = Deferred.when(d1, function(obj) {
928 calls++;
929 return obj * 2;
930 });
931 d1.addCallback(function(obj) {
932 assertEquals('Original chain should get original value', 5, obj);
933 calls++;
934 });
935 d2.addCallback(function(obj) {
936 assertEquals('Branched chain should get modified value', 10, obj);
937 calls++;
938 });
939
940 d1.callback(5);
941
942 assertEquals('There should have been 3 callbacks', 3, calls);
943 }
944
945 function testAssertNoErrors() {
946 var d = new Deferred();
947 d.addCallback(function() {
948 throw new Error('Foo');
949 });
950 d.callback(1);
951
952 var ex = assertThrows(function() {
953 Deferred.assertNoErrors();
954 neverHappen();
955 });
956 assertEquals('Expected to get thrown error', 'Foo', ex.message);
957
958 assertNotThrows(
959 'Calling Deferred.assertNoErrors() a second time with only one ' +
960 'scheduled error should pass.',
961 function() {
962 Deferred.assertNoErrors();
963 });
964 }
965
966 function testThen() {
967 var result;
968 var result2;
969 var d = new Deferred();
970 assertEquals(d.then, d['then']);
971 d.then(function(r) {
972 return result = r;
973 }).then(function (r2) {
974 result2 = r2;
975 });
976 d.callback('done');
977 assertUndefined(result);
978 mockClock.tick();
979 assertEquals('done', result);
980 assertEquals('done', result2);
981 }
982
983 function testThen_reject() {
984 var result, error;
985 var d = new Deferred();
986 assertEquals(d.then, d['then']);
987 d.then(function(r) {
988 result = r;
989 }, function(e) {
990 error = e;
991 });
992 d.errback(new Error('boom'));
993 assertUndefined(result);
994 mockClock.tick();
995 assertUndefined(result);
996 assertEquals('boom', error.message);
997 }
998
999 function testPromiseAll() {
1000 var d = new Deferred();
1001 var p = new goog.Promise(function(resolve) {
1002 resolve('promise');
1003 });
1004 goog.Promise.all([d, p]).then(function(values) {
1005 assertEquals(2, values.length);
1006 assertEquals('deferred', values[0]);
1007 assertEquals('promise', values[1]);
1008 });
1009 d.callback('deferred');
1010 mockClock.tick();
1011 }
1012
1013 function testGoogPromiseBlocksDeferred() {
1014 var result;
1015 var d = new Deferred();
1016 var p = new goog.Promise(function(resolve) {
1017 resolve('promise');
1018 });
1019 d.callback();
1020 d.addCallback(function() {
1021 return p;
1022 });
1023 d.addCallback(function(r) {
1024 result = r;
1025 });
1026
1027 assertUndefined(result);
1028 mockClock.tick();
1029 assertEquals('promise', result);
1030 }
1031
1032 function testNativePromiseBlocksDeferred() {
1033 // Early-out for browsers that don't support native Promises.
1034 if (typeof Promise !== 'function') {
1035 return;
1036 }
1037
1038 // Disable mock clock for this test. Native promises don't abide by it, so
1039 // it just complicates things in this case.
1040 mockClock.uninstall();
1041
1042 var blockedOnPromise = true;
1043
1044 var resolver;
1045 var d = Deferred.succeed();
1046 d.addCallback(function() {
1047 return new Promise(function(resolve) {
1048 resolver = resolve;
1049 });
1050 });
1051 d.addCallback(function(r) {
1052 blockedOnPromise = false;
1053 assertEquals('Native promise value', 'result', r);
1054 });
1055
1056 // Verify that the callback chain executes up to, but not beyond, the callback
1057 // that returns a Promise.
1058 assertTrue(!!resolver);
1059 assertTrue('Deferred chain not blocked on Promise resolution',
1060 blockedOnPromise);
1061 // Resolve the promise, which should unblock the rest of the callback chain.
1062 resolver('result');
1063 return d;
1064 }
1065
1066 function testFromPromise() {
1067 var result;
1068 var p = new goog.Promise(function(resolve) {
1069 resolve('promise');
1070 });
1071 var d = Deferred.fromPromise(p);
1072 d.addCallback(function(value) {
1073 result = value;
1074 });
1075 assertUndefined(result);
1076 mockClock.tick();
1077 assertEquals('promise', result);
1078 }
1079
1080 function testPromiseBlocksDeferredAndRejects() {
1081 var result;
1082 var d = new Deferred();
1083 var p = new goog.Promise(function(resolve, reject) {
1084 reject(new Error('error'));
1085 });
1086 d.callback();
1087 d.addCallback(function(r) {
1088 return p;
1089 });
1090 d.addErrback(function(r) {
1091 result = r;
1092 });
1093
1094 assertUndefined(result);
1095 mockClock.tick();
1096 assertEquals('error', result.message);
1097 }
1098
1099 function testPromiseFromCanceledDeferred() {
1100 var result;
1101 var d = new Deferred();
1102 d.cancel();
1103
1104 d.then(neverHappen, function(reason) {
1105 result = reason;
1106 });
1107
1108 mockClock.tick();
1109 assertTrue(result instanceof goog.Promise.CancellationError);
1110 }
1111
1112 function testThenableInterface() {
1113 var d = new Deferred();
1114 assertTrue(goog.Thenable.isImplementedBy(d));
1115 }
1116
1117 function testAddBothPropagatesToErrback() {
1118 var log = [];
1119 var deferred = new goog.async.Deferred();
1120 deferred.addBoth(goog.nullFunction);
1121 deferred.addErrback(function () {
1122 log.push('errback');
1123 });
1124 deferred.errback(new Error('my error'));
1125
1126 mockClock.tick(1);
1127 assertArrayEquals(['errback'], log);
1128 }
1129
1130 function testAddBothDoesNotPropagateUncaughtExceptions() {
1131 var deferred = new goog.async.Deferred();
1132 deferred.addBoth(goog.nullFunction);
1133 deferred.errback(new Error('my error'));
1134 mockClock.tick(1);
1135 }
1136
1137 function testAddFinally() {
1138 var deferred = new goog.async.Deferred();
1139 var callback = goog.testing.recordFunction();
1140 var thisArg = {};
1141 deferred.addFinally(callback, thisArg);
1142 deferred.errback(new Error('my error'));
1143
1144 try {
1145 mockClock.tick(1);
1146 } catch (e) {
1147 assertEquals('my error', e.message);
1148 }
1149 assertEquals(thisArg, callback.getCalls()[0].getThis());
1150 }