test/unit/ready.js

   1 QUnit.module( "ready" );
   2
   3 ( function() {
   4         var notYetReady, noEarlyExecution,
   5                 whenified = jQuery.when( jQuery.ready ),
   6                 promisified = Promise.resolve( jQuery.ready ),
   7                 start = new Date(),
   8                 order = [],
   9                 args = {};
  10
  11         notYetReady = !jQuery.isReady;
  12
  13         QUnit.test( "jQuery.isReady", function( assert ) {
  14                 assert.expect( 2 );
  15
  16                 assert.equal( notYetReady, true, "jQuery.isReady should not be true before DOM ready" );
  17                 assert.equal( jQuery.isReady, true, "jQuery.isReady should be true once DOM is ready" );
  18         } );
  19
  20         // Create an event handler.
  21         function makeHandler( testId ) {
  22
  23                 // When returned function is executed, push testId onto `order` array
  24                 // to ensure execution order. Also, store event handler arg to ensure
  25                 // the correct arg is being passed into the event handler.
  26                 return function( arg ) {
  27                         order.push( testId );
  28                         args[ testId ] = arg;
  29                 };
  30         }
  31
  32         function throwError( num ) {
  33
  34                 // Not a global QUnit failure
  35                 var onerror = window.onerror;
  36                 window.onerror = function() {
  37                         window.onerror = onerror;
  38                 };
  39
  40                 throw new Error( "Ready error " + num );
  41         }
  42
  43         // Bind to the ready event in every possible way.
  44         jQuery( makeHandler( "a" ) );
  45         jQuery( document ).ready( makeHandler( "b" ) );
  46         jQuery.ready.then( makeHandler( "c" ) );
  47
  48         // Throw in some errors
  49         jQuery( function() {
  50                 throwError( 1 );
  51         } );
  52         jQuery( function() {
  53                 throwError( 2 );
  54         } );
  55
  56         // Bind again to ensure that the errors didn't lock everything up
  57         jQuery( makeHandler( "d" ) );
  58         jQuery( document ).ready( makeHandler( "e" ) );
  59         jQuery.ready.then( makeHandler( "f" ) );
  60
  61         noEarlyExecution = order.length === 0;
  62
  63         // This assumes that QUnit tests are run on DOM ready!
  64         QUnit.test( "jQuery ready", function( assert ) {
  65                 assert.expect( 10 );
  66
  67                 assert.ok( noEarlyExecution,
  68                         "Handlers bound to DOM ready should not execute before DOM ready" );
  69
  70                 // Ensure execution order.
  71                 assert.deepEqual( order, [ "a", "b", "c", "d", "e", "f" ],
  72                         "Bound DOM ready handlers should execute in bind order" );
  73
  74                 // Ensure handler argument is correct.
  75                 assert.equal( args.a, jQuery,
  76                         "Argument passed to fn in jQuery( fn ) should be jQuery" );
  77                 assert.equal( args.b, jQuery,
  78                         "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery" );
  79
  80                 order = [];
  81
  82                 // Now that the ready event has fired, again bind to the ready event.
  83                 // These ready handlers should execute asynchronously.
  84                 var done = assert.async();
  85                 jQuery( makeHandler( "g" ) );
  86                 jQuery( document ).ready( makeHandler( "h" ) );
  87                 jQuery.ready.then( makeHandler( "i" ) );
  88                 window.setTimeout( function() {
  89                         assert.equal( order.shift(), "g",
  90                                 "Event handler should execute immediately, but async" );
  91                         assert.equal( args.g, jQuery,
  92                                 "Argument passed to fn in jQuery( fn ) should be jQuery" );
  93
  94                         assert.equal( order.shift(), "h",
  95                                 "Event handler should execute immediately, but async" );
  96                         assert.equal( args.h, jQuery,
  97                                 "Argument passed to fn in jQuery(document).ready( fn ) should be jQuery" );
  98
  99                         assert.equal( order.shift(), "i",
 100                                 "Event handler should execute immediately, but async" );
 101                         assert.equal( args.h, jQuery,
 102                                 "Argument passed to fn in jQuery.ready.then( fn ) should be jQuery" );
 103
 104                         done();
 105                 } );
 106         } );
 107
 108         QUnit.test( "jQuery.when(jQuery.ready)", function( assert ) {
 109                 assert.expect( 2 );
 110                 var done = jQuery.map( new Array( 2 ), function() { return assert.async(); } );
 111
 112                 whenified.then( function() {
 113                         assert.ok( jQuery.isReady, "jQuery.when Deferred resolved" );
 114                         done.pop()();
 115                 } );
 116
 117                 jQuery.when( jQuery.ready ).then( function() {
 118                         assert.ok( jQuery.isReady, "jQuery.when Deferred resolved" );
 119                         done.pop()();
 120                 } );
 121         } );
 122
 123         QUnit.test( "Promise.resolve(jQuery.ready)", function( assert ) {
 124                 assert.expect( 2 );
 125                 var done = jQuery.map( new Array( 2 ), function() { return assert.async(); } );
 126
 127                 promisified.then( function() {
 128                         assert.ok( jQuery.isReady, "Native promised resolved" );
 129                         done.pop()();
 130                 } );
 131
 132                 Promise.resolve( jQuery.ready ).then( function() {
 133                         assert.ok( jQuery.isReady, "Native promised resolved" );
 134                         done.pop()();
 135                 } );
 136         } );
 137
 138         QUnit.test( "Error in ready callback does not halt all future executions (gh-1823)", function( assert ) {
 139                 assert.expect( 1 );
 140                 var done = assert.async();
 141
 142                 jQuery( function() {
 143                         throwError( 3 );
 144                 } );
 145
 146                 jQuery( function() {
 147                         assert.ok( true, "Subsequent handler called" );
 148                         done();
 149                 } );
 150         } );
 151
 152         testIframe(
 153                 "holdReady test needs to be a standalone test since it deals with DOM ready",
 154                 "readywait.html",
 155                 function( assert, jQuery, window, document, releaseCalled ) {
 156                         assert.expect( 2 );
 157                         var now = new Date();
 158                         assert.ok( now - start >= 300, "Needs to have waited at least half a second" );
 159                         assert.ok( releaseCalled, "The release function was called, which resulted in ready" );
 160                 }
 161         );
 162
 163 } )();