test/unit/deferred.js

   1 module( "deferred", {
   2         teardown: moduleTeardown
   3 });
   4
   5 jQuery.each( [ "", " - new operator" ], function( _, withNew ) {
   6
   7         function createDeferred( fn ) {
   8                 return withNew ? new jQuery.Deferred( fn ) : jQuery.Deferred( fn );
   9         }
  10
  11         test( "jQuery.Deferred" + withNew, function() {
  12
  13                 expect( 23 );
  14
  15                 var defer = createDeferred();
  16
  17                 ok( jQuery.isFunction( defer.pipe ), "defer.pipe is a function" );
  18
  19                 createDeferred().resolve().done(function() {
  20                         ok( true, "Success on resolve" );
  21                         strictEqual( this.state(), "resolved", "Deferred is resolved (state)" );
  22                 }).fail(function() {
  23                         ok( false, "Error on resolve" );
  24                 }).always(function() {
  25                         ok( true, "Always callback on resolve" );
  26                 });
  27
  28                 createDeferred().reject().done(function() {
  29                         ok( false, "Success on reject" );
  30                 }).fail(function() {
  31                         ok( true, "Error on reject" );
  32                         strictEqual( this.state(), "rejected", "Deferred is rejected (state)" );
  33                 }).always(function() {
  34                         ok( true, "Always callback on reject" );
  35                 });
  36
  37                 createDeferred(function( defer ) {
  38                         ok( this === defer, "Defer passed as this & first argument" );
  39                         this.resolve("done");
  40                 }).done(function( value ) {
  41                         strictEqual( value, "done", "Passed function executed" );
  42                 });
  43
  44                 createDeferred(function( defer ) {
  45                         var promise = defer.promise(),
  46                                 func = function() {},
  47                                 funcPromise = defer.promise( func );
  48                         strictEqual( defer.promise(), promise, "promise is always the same" );
  49                         strictEqual( funcPromise, func, "non objects get extended" );
  50                         jQuery.each( promise, function( key ) {
  51                                 if ( !jQuery.isFunction( promise[ key ] ) ) {
  52                                         ok( false, key + " is a function (" + jQuery.type( promise[ key ] ) + ")" );
  53                                 }
  54                                 if ( promise[ key ] !== func[ key ] ) {
  55                                         strictEqual( func[ key ], promise[ key ], key + " is the same" );
  56                                 }
  57                         });
  58                 });
  59
  60                 jQuery.expandedEach = jQuery.each;
  61                 jQuery.expandedEach( "resolve reject".split(" "), function( _, change ) {
  62                         createDeferred(function( defer ) {
  63                                 strictEqual( defer.state(), "pending", "pending after creation" );
  64                                 var checked = 0;
  65                                 defer.progress(function( value ) {
  66                                         strictEqual( value, checked, "Progress: right value (" + value + ") received" );
  67                                 });
  68                                 for ( checked = 0; checked < 3; checked++ ) {
  69                                         defer.notify( checked );
  70                                 }
  71                                 strictEqual( defer.state(), "pending", "pending after notification" );
  72                                 defer[ change ]();
  73                                 notStrictEqual( defer.state(), "pending", "not pending after " + change );
  74                                 defer.notify();
  75                         });
  76                 });
  77         });
  78 });
  79
  80
  81 test( "jQuery.Deferred - chainability", function() {
  82
  83         var defer = jQuery.Deferred();
  84
  85         expect( 10 );
  86
  87         jQuery.expandedEach = jQuery.each;
  88         jQuery.expandedEach( "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split(" "), function( _, method ) {
  89                 var object = {
  90                         m: defer[ method ]
  91                 };
  92                 strictEqual( object.m(), object, method + " is chainable" );
  93         });
  94 });
  95
  96 test( "jQuery.Deferred.then - filtering (done)", function( assert ) {
  97
  98         assert.expect( 4 );
  99
 100         var value1, value2, value3,
 101                 defer = jQuery.Deferred(),
 102                 piped = defer.then(function( a, b ) {
 103                         return a * b;
 104                 }),
 105                 done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 106
 107         piped.done(function( result ) {
 108                 value3 = result;
 109         });
 110
 111         defer.done(function( a, b ) {
 112                 value1 = a;
 113                 value2 = b;
 114         });
 115
 116         defer.resolve( 2, 3 ).then(function() {
 117                 assert.strictEqual( value1, 2, "first resolve value ok" );
 118                 assert.strictEqual( value2, 3, "second resolve value ok" );
 119                 assert.strictEqual( value3, 6, "result of filter ok" );
 120                 done.pop().call();
 121         });
 122
 123         jQuery.Deferred().reject().then(function() {
 124                 assert.ok( false, "then should not be called on reject" );
 125         }).then( null, done.pop() );
 126
 127         jQuery.Deferred().resolve().then( jQuery.noop ).done(function( value ) {
 128                 assert.strictEqual( value, undefined, "then done callback can return undefined/null" );
 129                 done.pop().call();
 130         });
 131 });
 132
 133 test( "jQuery.Deferred.then - filtering (fail)", function( assert ) {
 134
 135         assert.expect( 4 );
 136
 137         var value1, value2, value3,
 138                 defer = jQuery.Deferred(),
 139                 piped = defer.then( null, function( a, b ) {
 140                         return a * b;
 141                 }),
 142                 done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 143
 144         piped.done(function( result ) {
 145                 value3 = result;
 146         });
 147
 148         defer.fail(function( a, b ) {
 149                 value1 = a;
 150                 value2 = b;
 151         });
 152
 153         defer.reject( 2, 3 ).then( null, function() {
 154                 assert.strictEqual( value1, 2, "first reject value ok" );
 155                 assert.strictEqual( value2, 3, "second reject value ok" );
 156                 assert.strictEqual( value3, 6, "result of filter ok" );
 157                 done.pop().call();
 158         });
 159
 160         jQuery.Deferred().resolve().then( null, function() {
 161                 assert.ok( false, "then should not be called on resolve" );
 162         }).then( done.pop() );
 163
 164         jQuery.Deferred().reject().then( null, jQuery.noop ).done(function( value ) {
 165                 assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
 166                 done.pop().call();
 167         });
 168 });
 169
 170 test( "jQuery.Deferred.catch", function( assert ) {
 171         assert.expect( 4 );
 172
 173         var value1, value2, value3,
 174                 defer = jQuery.Deferred(),
 175                 piped = defer[ "catch" ](function( a, b ) {
 176                         return a * b;
 177                 }),
 178                 done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 179
 180         piped.done(function( result ) {
 181                 value3 = result;
 182         });
 183
 184         defer.fail(function( a, b ) {
 185                 value1 = a;
 186                 value2 = b;
 187         });
 188
 189         defer.reject( 2, 3 )[ "catch" ](function() {
 190                 assert.strictEqual( value1, 2, "first reject value ok" );
 191                 assert.strictEqual( value2, 3, "second reject value ok" );
 192                 assert.strictEqual( value3, 6, "result of filter ok" );
 193                 done.pop().call();
 194         });
 195
 196         jQuery.Deferred().resolve()[ "catch" ](function() {
 197                 assert.ok( false, "then should not be called on resolve" );
 198         }).then( done.pop() );
 199
 200         jQuery.Deferred().reject()[ "catch" ]( jQuery.noop ).done(function( value ) {
 201                 assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
 202                 done.pop().call();
 203         });
 204 });
 205
 206 test( "[PIPE ONLY] jQuery.Deferred.pipe - filtering (fail)", function( assert ) {
 207
 208         assert.expect( 4 );
 209
 210         var value1, value2, value3,
 211                 defer = jQuery.Deferred(),
 212                 piped = defer.pipe( null, function( a, b ) {
 213                         return a * b;
 214                 }),
 215                 done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 216
 217         piped.fail(function( result ) {
 218                 value3 = result;
 219         });
 220
 221         defer.fail(function( a, b ) {
 222                 value1 = a;
 223                 value2 = b;
 224         });
 225
 226         defer.reject( 2, 3 ).pipe( null, function() {
 227                 assert.strictEqual( value1, 2, "first reject value ok" );
 228                 assert.strictEqual( value2, 3, "second reject value ok" );
 229                 assert.strictEqual( value3, 6, "result of filter ok" );
 230                 done.pop().call();
 231         });
 232
 233         jQuery.Deferred().resolve().pipe( null, function() {
 234                 assert.ok( false, "then should not be called on resolve" );
 235         }).then( done.pop() );
 236
 237         jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail(function( value ) {
 238                 assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
 239                 done.pop().call();
 240         });
 241 });
 242
 243 test( "jQuery.Deferred.then - filtering (progress)", function( assert ) {
 244
 245         assert.expect( 3 );
 246
 247         var value1, value2, value3,
 248                 defer = jQuery.Deferred(),
 249                 piped = defer.then( null, null, function( a, b ) {
 250                         return a * b;
 251                 }),
 252                 done = assert.async();
 253
 254         piped.progress(function( result ) {
 255                 value3 = result;
 256         });
 257
 258         defer.progress(function( a, b ) {
 259                 value1 = a;
 260                 value2 = b;
 261         });
 262
 263         defer.notify( 2, 3 ).then( null, null, function() {
 264                 assert.strictEqual( value1, 2, "first progress value ok" );
 265                 assert.strictEqual( value2, 3, "second progress value ok" );
 266                 assert.strictEqual( value3, 6, "result of filter ok" );
 267                 done();
 268         });
 269 });
 270
 271 test( "jQuery.Deferred.then - deferred (done)", function( assert ) {
 272
 273         assert.expect( 3 );
 274
 275         var value1, value2, value3,
 276                 defer = jQuery.Deferred(),
 277                 piped = defer.then(function( a, b ) {
 278                         return jQuery.Deferred(function( defer ) {
 279                                 defer.reject( a * b );
 280                         });
 281                 }),
 282                 done = assert.async();
 283
 284         piped.fail(function( result ) {
 285                 value3 = result;
 286         });
 287
 288         defer.done(function( a, b ) {
 289                 value1 = a;
 290                 value2 = b;
 291         });
 292
 293         defer.resolve( 2, 3 );
 294
 295         piped.fail(function() {
 296                 assert.strictEqual( value1, 2, "first resolve value ok" );
 297                 assert.strictEqual( value2, 3, "second resolve value ok" );
 298                 assert.strictEqual( value3, 6, "result of filter ok" );
 299                 done();
 300         });
 301 });
 302
 303 test( "jQuery.Deferred.then - deferred (fail)", function( assert ) {
 304
 305         assert.expect( 3 );
 306
 307         var value1, value2, value3,
 308                 defer = jQuery.Deferred(),
 309                 piped = defer.then( null, function( a, b ) {
 310                         return jQuery.Deferred(function( defer ) {
 311                                 defer.resolve( a * b );
 312                         });
 313                 }),
 314                 done = assert.async();
 315
 316         piped.done(function( result ) {
 317                 value3 = result;
 318         });
 319
 320         defer.fail(function( a, b ) {
 321                 value1 = a;
 322                 value2 = b;
 323         });
 324
 325         defer.reject( 2, 3 );
 326
 327         piped.done(function() {
 328                 assert.strictEqual( value1, 2, "first reject value ok" );
 329                 assert.strictEqual( value2, 3, "second reject value ok" );
 330                 assert.strictEqual( value3, 6, "result of filter ok" );
 331                 done();
 332         });
 333 });
 334
 335 test( "jQuery.Deferred.then - deferred (progress)", function( assert ) {
 336
 337         assert.expect( 3 );
 338
 339         var value1, value2, value3,
 340                 defer = jQuery.Deferred(),
 341                 piped = defer.then( null, null, function( a, b ) {
 342                         return jQuery.Deferred(function( defer ) {
 343                                 defer.resolve( a * b );
 344                         });
 345                 }),
 346                 done = assert.async();
 347
 348         piped.progress(function( result ) {
 349                 return jQuery.Deferred().resolve().then(function() {
 350                         return result;
 351                 }).then(function( result ) {
 352                         value3 = result;
 353                 });
 354         });
 355
 356         defer.progress(function( a, b ) {
 357                 value1 = a;
 358                 value2 = b;
 359         });
 360
 361         defer.notify( 2, 3 );
 362
 363         piped.then( null, null, function( result ) {
 364                 return jQuery.Deferred().resolve().then(function() {
 365                         return result;
 366                 }).then(function() {
 367                         assert.strictEqual( value1, 2, "first progress value ok" );
 368                         assert.strictEqual( value2, 3, "second progress value ok" );
 369                         assert.strictEqual( value3, 6, "result of filter ok" );
 370                         done();
 371                 });
 372         });
 373 });
 374
 375 test( "[PIPE ONLY] jQuery.Deferred.pipe - deferred (progress)", function( assert ) {
 376
 377         assert.expect( 3 );
 378
 379         var value1, value2, value3,
 380                 defer = jQuery.Deferred(),
 381                 piped = defer.pipe( null, null, function( a, b ) {
 382                         return jQuery.Deferred(function( defer ) {
 383                                 defer.resolve( a * b );
 384                         });
 385                 }),
 386                 done = assert.async();
 387
 388         piped.done(function( result ) {
 389                 value3 = result;
 390         });
 391
 392         defer.progress(function( a, b ) {
 393                 value1 = a;
 394                 value2 = b;
 395         });
 396
 397         defer.notify( 2, 3 );
 398
 399         piped.done(function() {
 400                 assert.strictEqual( value1, 2, "first progress value ok" );
 401                 assert.strictEqual( value2, 3, "second progress value ok" );
 402                 assert.strictEqual( value3, 6, "result of filter ok" );
 403                 done();
 404         });
 405 });
 406
 407 test( "jQuery.Deferred.then - context", function( assert ) {
 408
 409         assert.expect( 7 );
 410
 411         var defer, piped, defer2, piped2,
 412                 context = {},
 413                 done = jQuery.map( new Array( 4 ), function() { return assert.async(); } );
 414
 415         jQuery.Deferred().resolveWith( context, [ 2 ] ).then(function( value ) {
 416                 return value * 3;
 417         }).done(function( value ) {
 418                 assert.notStrictEqual( this, context, "custom context not propagated through .then" );
 419                 assert.strictEqual( value, 6, "proper value received" );
 420                 done.pop().call();
 421         });
 422
 423         jQuery.Deferred().resolve().then(function() {
 424                 return jQuery.Deferred().resolveWith( context );
 425         }).done(function() {
 426                 assert.strictEqual( this, context,
 427                         "custom context of returned deferred correctly propagated" );
 428                 done.pop().call();
 429         });
 430
 431         defer = jQuery.Deferred();
 432         piped = defer.then(function( value ) {
 433                 return value * 3;
 434         });
 435
 436         defer.resolve( 2 );
 437
 438         piped.done(function( value ) {
 439                 assert.strictEqual( this, piped,
 440                         "default context gets updated to latest promise in the chain" );
 441                 assert.strictEqual( value, 6, "proper value received" );
 442                 done.pop().call();
 443         });
 444
 445         defer2 = jQuery.Deferred();
 446         piped2 = defer2.then();
 447
 448         defer2.resolve( 2 );
 449
 450         piped2.done(function( value ) {
 451                 assert.strictEqual( this, piped2,
 452                         "default context updated to latest promise in the chain (without passing function)" );
 453                 assert.strictEqual( value, 2, "proper value received (without passing function)" );
 454                 done.pop().call();
 455         });
 456 });
 457
 458 test( "[PIPE ONLY] jQuery.Deferred.pipe - context", function( assert ) {
 459
 460         assert.expect( 7 );
 461
 462         var defer, piped, defer2, piped2,
 463                 context = {},
 464                 done = jQuery.map( new Array( 4 ), function() { return assert.async(); } );
 465
 466         jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe(function( value ) {
 467                 return value * 3;
 468         }).done(function( value ) {
 469                 assert.strictEqual( this, context, "[PIPE ONLY] custom context correctly propagated" );
 470                 assert.strictEqual( value, 6, "proper value received" );
 471                 done.pop().call();
 472         });
 473
 474         jQuery.Deferred().resolve().pipe(function() {
 475                 return jQuery.Deferred().resolveWith(context);
 476         }).done(function() {
 477                 assert.strictEqual( this, context,
 478                         "custom context of returned deferred correctly propagated" );
 479                 done.pop().call();
 480         });
 481
 482         defer = jQuery.Deferred();
 483         piped = defer.pipe(function( value ) {
 484                 return value * 3;
 485         });
 486
 487         defer.resolve( 2 );
 488
 489         piped.done(function( value ) {
 490                 assert.strictEqual( this, piped,
 491                         "default context gets updated to latest promise in the chain" );
 492                 assert.strictEqual( value, 6, "proper value received" );
 493                 done.pop().call();
 494         });
 495
 496         defer2 = jQuery.Deferred();
 497         piped2 = defer2.pipe();
 498
 499         defer2.resolve( 2 );
 500
 501         piped2.done(function( value ) {
 502                 assert.strictEqual( this, piped2,
 503                         "default context updated to latest promise in the chain (without passing function)" );
 504                 assert.strictEqual( value, 2, "proper value received (without passing function)" );
 505                 done.pop().call();
 506         });
 507 });
 508
 509 asyncTest( "jQuery.Deferred.then - spec compatibility", function() {
 510
 511         expect( 1 );
 512
 513         var defer = jQuery.Deferred().done(function() {
 514                 setTimeout( start );
 515                 throw new Error();
 516         });
 517
 518         defer.then(function() {
 519                 ok( true, "errors in .done callbacks don't stop .then handlers" );
 520         });
 521
 522         try {
 523                 defer.resolve();
 524         } catch ( _ ) {}
 525 });
 526
 527 test( "jQuery.Deferred - 1.x/2.x compatibility", function( assert ) {
 528
 529         expect( 8 );
 530
 531         var context = { id: "callback context" },
 532                 thenable = jQuery.Deferred().resolve( "thenable fulfillment" ).promise(),
 533                 done = jQuery.map( new Array( 8 ), function() { return assert.async(); } );
 534
 535         thenable.unwrapped = false;
 536
 537         jQuery.Deferred().resolve( 1, 2 ).then(function() {
 538                 assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
 539                         ".then fulfillment callbacks receive all resolution values" );
 540                 done.pop().call();
 541         });
 542         jQuery.Deferred().reject( 1, 2 ).then( null, function() {
 543                 assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
 544                         ".then rejection callbacks receive all rejection values" );
 545                 done.pop().call();
 546         });
 547         jQuery.Deferred().notify( 1, 2 ).then( null, null, function() {
 548                 assert.deepEqual( [].slice.call( arguments ), [ 1, 2 ],
 549                         ".then progress callbacks receive all progress values" );
 550                 done.pop().call();
 551         });
 552
 553         jQuery.Deferred().resolveWith( context ).then(function() {
 554                 assert.deepEqual( this, context, ".then fulfillment callbacks receive context" );
 555                 done.pop().call();
 556         });
 557         jQuery.Deferred().rejectWith( context ).then( null, function() {
 558                 assert.deepEqual( this, context, ".then rejection callbacks receive context" );
 559                 done.pop().call();
 560         });
 561         jQuery.Deferred().notifyWith( context ).then( null, null, function() {
 562                 assert.deepEqual( this, context, ".then progress callbacks receive context" );
 563                 done.pop().call();
 564         });
 565
 566         jQuery.Deferred().resolve( thenable ).done(function( value ) {
 567                 assert.strictEqual( value, thenable, ".done doesn't unwrap thenables" );
 568                 done.pop().call();
 569         });
 570
 571         jQuery.Deferred().notify( thenable ).then().then( null, null, function( value ) {
 572                 assert.strictEqual( value, "thenable fulfillment",
 573                         ".then implicit progress callbacks unwrap thenables" );
 574                 done.pop().call();
 575         });
 576 });
 577
 578 test( "jQuery.Deferred.then - progress and thenables", function( assert ) {
 579
 580         expect( 2 );
 581
 582         var trigger = jQuery.Deferred().notify(),
 583                 expectedProgress = [ "baz", "baz" ],
 584                 done = jQuery.map( new Array( 2 ), function() { return assert.async(); } ),
 585                 failer = function( evt ) {
 586                         return function() {
 587                                 ok( false, "no unexpected " + evt );
 588                         };
 589                 };
 590
 591         trigger.then( null, null, function() {
 592                 var notifier = jQuery.Deferred().notify( "foo" );
 593                 setTimeout(function() {
 594                         notifier.notify( "bar" ).resolve( "baz" );
 595                 });
 596                 return notifier;
 597         }).then( failer( "fulfill" ), failer( "reject" ), function( v ) {
 598                 assert.strictEqual( v, expectedProgress.shift(), "expected progress value" );
 599                 done.pop().call();
 600         });
 601         trigger.notify();
 602 });
 603
 604 test( "jQuery.Deferred - notify and resolve", function( assert ) {
 605
 606         expect( 7 );
 607
 608         var notifiedResolved = jQuery.Deferred().notify( "foo" )/*xxx .resolve( "bar" )*/,
 609                 done = jQuery.map( new Array( 3 ), function() { return assert.async(); } );
 610
 611         notifiedResolved.progress( function( v ) {
 612                 assert.strictEqual( v, "foo", "progress value" );
 613         } );
 614
 615         notifiedResolved.pipe().progress( function( v ) {
 616                 assert.strictEqual( v, "foo", "piped progress value" );
 617         } );
 618
 619         notifiedResolved.pipe( null, null, function() {
 620                 return "baz";
 621         } ).progress( function( v ) {
 622                 assert.strictEqual( v, "baz", "replaced piped progress value" );
 623         } );
 624
 625         notifiedResolved.pipe( null, null, function() {
 626                 return jQuery.Deferred().notify( "baz" ).resolve( "quux" );
 627         } ).progress( function( v ) {
 628                 assert.strictEqual( v, "baz", "deferred replaced piped progress value" );
 629         } );
 630
 631         notifiedResolved.then().progress( function( v ) {
 632                 assert.strictEqual( v, "foo", "then'd progress value" );
 633                 done.pop().call();
 634         } );
 635
 636         notifiedResolved.then( null, null, function() {
 637                 return "baz";
 638         } ).progress( function( v ) {
 639                 assert.strictEqual( v, "baz", "replaced then'd progress value" );
 640                 done.pop().call();
 641         } );
 642
 643         notifiedResolved.then( null, null, function() {
 644                 return jQuery.Deferred().notify( "baz" ).resolve( "quux" );
 645         } ).progress( function( v ) {
 646                 // Progress from the surrogate deferred is ignored
 647                 assert.strictEqual( v, "quux", "deferred replaced then'd progress value" );
 648                 done.pop().call();
 649         } );
 650 });
 651
 652 test( "jQuery.when", function() {
 653
 654         expect( 37 );
 655
 656         // Some other objects
 657         jQuery.each({
 658                 "an empty string": "",
 659                 "a non-empty string": "some string",
 660                 "zero": 0,
 661                 "a number other than zero": 1,
 662                 "true": true,
 663                 "false": false,
 664                 "null": null,
 665                 "undefined": undefined,
 666                 "a plain object": {},
 667                 "an array": [ 1, 2, 3 ]
 668
 669         }, function( message, value ) {
 670                 ok(
 671                         jQuery.isFunction(
 672                                 jQuery.when( value ).done(function( resolveValue ) {
 673                                         strictEqual( this, window, "Context is the global object with " + message );
 674                                         strictEqual( resolveValue, value, "Test the promise was resolved with " + message );
 675                                 }).promise
 676                         ),
 677                         "Test " + message + " triggers the creation of a new Promise"
 678                 );
 679         });
 680
 681         ok(
 682                 jQuery.isFunction(
 683                         jQuery.when().done(function( resolveValue ) {
 684                                 strictEqual( this, window, "Test the promise was resolved with window as its context" );
 685                                 strictEqual( resolveValue, undefined, "Test the promise was resolved with no parameter" );
 686                         }).promise
 687                 ),
 688                 "Test calling when with no parameter triggers the creation of a new Promise"
 689         );
 690
 691         var cache,
 692                 context = {};
 693
 694         jQuery.when( jQuery.Deferred().resolveWith( context ) ).done(function() {
 695                 strictEqual( this, context, "when( promise ) propagates context" );
 696         });
 697
 698         jQuery.each([ 1, 2, 3 ], function( k, i ) {
 699
 700                 jQuery.when( cache || jQuery.Deferred(function() {
 701                                 this.resolve( i );
 702                         })
 703                 ).done(function( value ) {
 704
 705                         strictEqual( value, 1, "Function executed" + ( i > 1 ? " only once" : "" ) );
 706                         cache = value;
 707                 });
 708
 709         });
 710 });
 711
 712 test( "jQuery.when - joined", function() {
 713
 714         expect( 195 );
 715
 716         var deferreds = {
 717                         rawValue: 1,
 718                         fulfilled: jQuery.Deferred().resolve( 1 ),
 719                         rejected: jQuery.Deferred().reject( 0 ),
 720                         notified: jQuery.Deferred().notify( true ),
 721                         eventuallyFulfilled: jQuery.Deferred().notify( true ),
 722                         eventuallyRejected: jQuery.Deferred().notify( true ),
 723                         fulfilledStandardPromise: Promise.resolve( 1 ),
 724                         rejectedStandardPromise: Promise.reject( 0 )
 725                 },
 726                 willSucceed = {
 727                         rawValue: true,
 728                         fulfilled: true,
 729                         eventuallyFulfilled: true,
 730                         fulfilledStandardPromise: true
 731                 },
 732                 willError = {
 733                         rejected: true,
 734                         eventuallyRejected: true,
 735                         rejectedStandardPromise: true
 736                 },
 737                 willNotify = {
 738                         notified: true,
 739                         eventuallyFulfilled: true,
 740                         eventuallyRejected: true
 741                 },
 742                 counter = 49;
 743
 744         stop();
 745
 746         function restart() {
 747                 if ( !--counter ) {
 748                         start();
 749                 }
 750         }
 751
 752         jQuery.each( deferreds, function( id1, defer1 ) {
 753                 jQuery.each( deferreds, function( id2, defer2 ) {
 754                         var shouldResolve = willSucceed[ id1 ] && willSucceed[ id2 ],
 755                                 shouldError = willError[ id1 ] || willError[ id2 ],
 756                                 shouldNotify = willNotify[ id1 ] || willNotify[ id2 ],
 757                                 expected = shouldResolve ? [ 1, 1 ] : [ 0, undefined ],
 758                                 expectedNotify = shouldNotify && [ willNotify[ id1 ], willNotify[ id2 ] ],
 759                                 code = "jQuery.when( " + id1 + ", " + id2 + " )",
 760                                 context1 = defer1 && jQuery.isFunction( defer1.promise ) ? defer1.promise() :
 761                                         ( defer1.then ? window : undefined ),
 762                                 context2 = defer2 && jQuery.isFunction( defer2.promise ) ? defer2.promise() :
 763                                         ( defer2.then ? window : undefined );
 764
 765                         jQuery.when( defer1, defer2 ).done(function( a, b ) {
 766                                 if ( shouldResolve ) {
 767                                         deepEqual( [ a, b ], expected, code + " => resolve" );
 768                                         strictEqual( this[ 0 ], context1, code + " => first context OK" );
 769                                         strictEqual( this[ 1 ], context2, code + " => second context OK" );
 770                                 } else {
 771                                         ok( false,  code + " => resolve" );
 772                                 }
 773                         }).fail(function( a, b ) {
 774                                 if ( shouldError ) {
 775                                         deepEqual( [ a, b ], expected, code + " => reject" );
 776                                 } else {
 777                                         ok( false, code + " => reject" );
 778                                 }
 779                         }).progress(function( a, b ) {
 780                                 deepEqual( [ a, b ], expectedNotify, code + " => progress" );
 781                                 strictEqual( this[ 0 ], expectedNotify[ 0 ] ? context1 : undefined, code + " => first context OK" );
 782                                 strictEqual( this[ 1 ], expectedNotify[ 1 ] ? context2 : undefined, code + " => second context OK" );
 783                         }).always( restart );
 784                 });
 785         });
 786         deferreds.eventuallyFulfilled.resolve( 1 );
 787         deferreds.eventuallyRejected.reject( 0 );
 788 });
 789
 790 test( "jQuery.when - resolved", function() {
 791
 792         expect( 6 );
 793
 794         var a = jQuery.Deferred().notify( 1 ).resolve( 4 ),
 795                 b = jQuery.Deferred().notify( 2 ).resolve( 5 ),
 796                 c = jQuery.Deferred().notify( 3 ).resolve( 6 );
 797
 798         jQuery.when( a, b, c ).progress(function( a, b, c ) {
 799                 strictEqual( a, 1, "first notify value ok" );
 800                 strictEqual( b, 2, "second notify value ok" );
 801                 strictEqual( c, 3, "third notify value ok" );
 802         }).done(function( a, b, c ) {
 803                 strictEqual( a, 4, "first resolve value ok" );
 804                 strictEqual( b, 5, "second resolve value ok" );
 805                 strictEqual( c, 6, "third resolve value ok" );
 806         }).fail(function() {
 807                 ok( false, "Error on resolve" );
 808         });
 809 });
 810
 811 test( "jQuery.when - filtering", function() {
 812
 813         expect( 2 );
 814
 815         function increment( x ) {
 816                 return x + 1;
 817         }
 818
 819         stop();
 820
 821         jQuery.when(
 822                 jQuery.Deferred().resolve( 3 ).then( increment ),
 823                 jQuery.Deferred().reject( 5 ).then( null, increment )
 824         ).done(function( four, six ) {
 825                 strictEqual( four, 4, "resolved value incremented" );
 826                 strictEqual( six, 6, "rejected value incremented" );
 827                 start();
 828         });
 829 });
 830
 831 test( "jQuery.when - exceptions", function() {
 832
 833         expect( 2 );
 834
 835         function woops() {
 836                 throw "exception thrown";
 837         }
 838
 839         stop();
 840
 841         jQuery.Deferred().resolve().then( woops ).fail(function( doneException ) {
 842                 strictEqual( doneException, "exception thrown", "throwing in done handler" );
 843                 jQuery.Deferred().reject().then( null, woops ).fail(function( failException ) {
 844                         strictEqual( failException, "exception thrown", "throwing in fail handler" );
 845                         start();
 846                 });
 847         });
 848 });
 849
 850 test( "jQuery.when - chaining", function() {
 851
 852         expect( 4 );
 853
 854         var defer = jQuery.Deferred();
 855
 856         function chain() {
 857                 return defer;
 858         }
 859
 860         function chainStandard() {
 861                 return Promise.resolve( "std deferred" );
 862         }
 863
 864         stop();
 865
 866         jQuery.when(
 867                 jQuery.Deferred().resolve( 3 ).then( chain ),
 868                 jQuery.Deferred().reject( 5 ).then( null, chain ),
 869                 jQuery.Deferred().resolve( 3 ).then( chainStandard ),
 870                 jQuery.Deferred().reject( 5 ).then( null, chainStandard )
 871         ).done(function( v1, v2, s1, s2 ) {
 872                 strictEqual( v1, "other deferred", "chaining in done handler" );
 873                 strictEqual( v2, "other deferred", "chaining in fail handler" );
 874                 strictEqual( s1, "std deferred", "chaining thenable in done handler" );
 875                 strictEqual( s2, "std deferred", "chaining thenable in fail handler" );
 876                 start();
 877         });
 878
 879         defer.resolve( "other deferred" );
 880 });