test/unit/queue.js

   1 QUnit.module( "queue", { afterEach: moduleTeardown } );
   2
   3 ( function() {
   4
   5 if ( !includesModule( "queue" ) ) {
   6         return;
   7 }
   8
   9 QUnit.test( "queue() with other types", function( assert ) {
  10         var done = assert.async( 2 );
  11         assert.expect( 14 );
  12
  13
  14         var $div = jQuery( {} ),
  15                 counter = 0;
  16
  17         $div.promise( "foo" ).done( function() {
  18                 assert.equal( counter, 0, "Deferred for collection with no queue is automatically resolved" );
  19         } );
  20
  21         $div
  22                 .queue( "foo", function() {
  23                         assert.equal( ++counter, 1, "Dequeuing" );
  24                         jQuery.dequeue( this, "foo" );
  25                 } )
  26                 .queue( "foo", function() {
  27                         assert.equal( ++counter, 2, "Dequeuing" );
  28                         jQuery( this ).dequeue( "foo" );
  29                 } )
  30                 .queue( "foo", function() {
  31                         assert.equal( ++counter, 3, "Dequeuing" );
  32                 } )
  33                 .queue( "foo", function() {
  34                         assert.equal( ++counter, 4, "Dequeuing" );
  35                 } );
  36
  37         $div.promise( "foo" ).done( function() {
  38                 assert.equal( counter, 4, "Testing previous call to dequeue in deferred"  );
  39                 done();
  40         } );
  41
  42         assert.equal( $div.queue( "foo" ).length, 4, "Testing queue length" );
  43
  44         assert.equal( $div.queue( "foo", undefined ).queue( "foo" ).length, 4, ".queue('name',undefined) does nothing but is chainable (trac-5571)" );
  45
  46         $div.dequeue( "foo" );
  47
  48         assert.equal( counter, 3, "Testing previous call to dequeue" );
  49         assert.equal( $div.queue( "foo" ).length, 1, "Testing queue length" );
  50
  51         $div.dequeue( "foo" );
  52
  53         assert.equal( counter, 4, "Testing previous call to dequeue" );
  54         assert.equal( $div.queue( "foo" ).length, 0, "Testing queue length" );
  55
  56         $div.dequeue( "foo" );
  57
  58         assert.equal( counter, 4, "Testing previous call to dequeue" );
  59         assert.equal( $div.queue( "foo" ).length, 0, "Testing queue length" );
  60         done();
  61 } );
  62
  63 QUnit.test( "queue(name) passes in the next item in the queue as a parameter", function( assert ) {
  64         assert.expect( 2 );
  65
  66         var div = jQuery( {} ),
  67                 counter = 0;
  68
  69         div.queue( "foo", function( next ) {
  70                 assert.equal( ++counter, 1, "Dequeueing" );
  71                 next();
  72         } ).queue( "foo", function( next ) {
  73                 assert.equal( ++counter, 2, "Next was called" );
  74                 next();
  75         } ).queue( "bar", function() {
  76                 assert.equal( ++counter, 3, "Other queues are not triggered by next()" );
  77         } );
  78
  79         div.dequeue( "foo" );
  80 } );
  81
  82 QUnit.test( "queue() passes in the next item in the queue as a parameter to fx queues", function( assert ) {
  83         var done = assert.async();
  84         assert.expect( 3 );
  85
  86         var div = jQuery( {} ),
  87                 counter = 0;
  88
  89         div.queue( function( next ) {
  90                 assert.equal( ++counter, 1, "Dequeueing" );
  91                 setTimeout( function() { next(); }, 500 );
  92         } ).queue( function( next ) {
  93                 assert.equal( ++counter, 2, "Next was called" );
  94                 next();
  95         } ).queue( "bar", function() {
  96                 assert.equal( ++counter, 3, "Other queues are not triggered by next()" );
  97         } );
  98
  99         jQuery.when( div.promise( "fx" ), div ).done( function() {
 100                 assert.equal( counter, 2, "Deferreds resolved" );
 101                 done();
 102         } );
 103 } );
 104
 105 QUnit.test( "callbacks keep their place in the queue", function( assert ) {
 106         var done = assert.async();
 107         assert.expect( 5 );
 108         var div = jQuery( "<div>" ),
 109                 counter = 0;
 110
 111         div.queue( function( next ) {
 112                 assert.equal( ++counter, 1, "Queue/callback order: first called" );
 113                 setTimeout( next, 200 );
 114         } ).delay( 100 ).queue( function( next ) {
 115                 assert.equal( ++counter, 2, "Queue/callback order: second called" );
 116                 jQuery( this ).delay( 100 ).queue( function( next ) {
 117                         assert.equal( ++counter, 4, "Queue/callback order: fourth called" );
 118                         next();
 119                 } );
 120                 next();
 121         } ).queue( function( next ) {
 122                 assert.equal( ++counter, 3, "Queue/callback order: third called" );
 123                 next();
 124         } );
 125
 126         div.promise( "fx" ).done( function() {
 127                 assert.equal( counter, 4, "Deferreds resolved" );
 128                 done();
 129         } );
 130 } );
 131
 132 QUnit.test( "jQuery.queue should return array while manipulating the queue", function( assert ) {
 133         assert.expect( 1 );
 134
 135         var div = document.createElement( "div" );
 136
 137         assert.ok( Array.isArray( jQuery.queue( div, "fx", jQuery.noop ) ), "jQuery.queue should return an array while manipulating the queue" );
 138 } );
 139
 140 QUnit.test( "delay()", function( assert ) {
 141         var done = assert.async();
 142         assert.expect( 2 );
 143
 144         var foo = jQuery( {} ), run = 0;
 145
 146         foo.delay( 100 ).queue( function() {
 147                 run = 1;
 148                 assert.ok( true, "The function was dequeued." );
 149                 done();
 150         } );
 151
 152         assert.equal( run, 0, "The delay delayed the next function from running." );
 153 } );
 154
 155 QUnit.test( "clearQueue(name) clears the queue", function( assert ) {
 156         var done = assert.async( 2 );
 157         assert.expect( 2 );
 158
 159         var div = jQuery( {} ),
 160                 counter = 0;
 161
 162         div.queue( "foo", function( next ) {
 163                 counter++;
 164                 jQuery( this ).clearQueue( "foo" );
 165                 next();
 166         } ).queue( "foo", function() {
 167                 counter++;
 168         } );
 169
 170         div.promise( "foo" ).done( function() {
 171                 assert.ok( true, "dequeue resolves the deferred" );
 172                 done();
 173         } );
 174
 175         div.dequeue( "foo" );
 176
 177         assert.equal( counter, 1, "the queue was cleared" );
 178         done();
 179 } );
 180
 181 QUnit.test( "clearQueue() clears the fx queue", function( assert ) {
 182         assert.expect( 1 );
 183
 184         var div = jQuery( {} ),
 185                 counter = 0;
 186
 187         div.queue( function( next ) {
 188                 counter++;
 189                 var self = this;
 190                 setTimeout( function() { jQuery( self ).clearQueue(); next(); }, 50 );
 191         } ).queue( function() {
 192                 counter++;
 193         } );
 194
 195         assert.equal( counter, 1, "the queue was cleared" );
 196
 197         div.removeData();
 198 } );
 199
 200 QUnit.test( "fn.promise() - called when fx queue is empty", function( assert ) {
 201         assert.expect( 3 );
 202         var foo = jQuery( "#foo" ).clone().addBack(),
 203                 promised = false,
 204                 done = assert.async();
 205
 206         foo.queue( function( next ) {
 207
 208                 // called twice!
 209                 assert.ok( !promised, "Promised hasn't been called" );
 210                 setTimeout( next, 10 );
 211         } );
 212         foo.promise().done( function() {
 213                 assert.ok( promised = true, "Promised" );
 214                 done();
 215         } );
 216 } );
 217
 218 QUnit.test( "fn.promise( \"queue\" ) - called whenever last queue function is dequeued", function( assert ) {
 219         assert.expect( 5 );
 220         var done = assert.async();
 221         var foo = jQuery( "#foo" ),
 222                 test;
 223         foo.promise( "queue" ).done( function() {
 224                 assert.strictEqual( test, undefined, "called immediately when queue was already empty" );
 225         } );
 226         test = 1;
 227         foo.queue( "queue", function( next ) {
 228                 assert.strictEqual( test++, 1, "step one" );
 229                 setTimeout( next, 0 );
 230         } ).queue( "queue", function( next ) {
 231                 assert.strictEqual( test++, 2, "step two" );
 232                 setTimeout( function() {
 233                         next();
 234                         assert.strictEqual( test++, 4, "step four" );
 235                         done();
 236                 }, 10 );
 237         } ).promise( "queue" ).done( function() {
 238                 assert.strictEqual( test++, 3, "step three" );
 239         } );
 240
 241         foo.dequeue( "queue" );
 242 } );
 243
 244 if ( includesModule( "effects" ) ) {
 245
 246 QUnit.test( "fn.promise( \"queue\" ) - waits for animation to complete before resolving", function( assert ) {
 247         assert.expect( 2 );
 248         var done = assert.async();
 249         var foo = jQuery( "#foo" ),
 250                 test = 1;
 251
 252         foo.animate( {
 253                 top: 100
 254         }, {
 255                 duration: 1,
 256                 queue: "queue",
 257                 complete: function() {
 258                         assert.strictEqual( test++, 1, "step one" );
 259                 }
 260         } ).dequeue( "queue" );
 261
 262         foo.promise( "queue" ).done( function() {
 263                 assert.strictEqual( test++, 2, "step two" );
 264                 done();
 265         } );
 266
 267 } );
 268 }
 269
 270 QUnit.test( ".promise(obj)", function( assert ) {
 271         assert.expect( 2 );
 272
 273         var obj = {},
 274                 promise = jQuery( "#foo" ).promise( "promise", obj );
 275
 276         assert.ok( typeof promise.promise === "function", ".promise(type, obj) returns a promise" );
 277         assert.strictEqual( promise, obj, ".promise(type, obj) returns obj" );
 278 } );
 279
 280 QUnit[ includesModule( "effects" ) ? "test" : "skip" ]( "delay() can be stopped", function( assert ) {
 281         var done = assert.async();
 282         assert.expect( 3 );
 283         var storage = {};
 284         jQuery( {} )
 285                 .queue( "alternate", function( next ) {
 286                         storage.alt1 = true;
 287                         assert.ok( true, "This first function was dequeued" );
 288                         next();
 289                 } )
 290                 .delay( 1000, "alternate" )
 291                 .queue( "alternate", function() {
 292                         storage.alt2 = true;
 293                         assert.ok( true, "The function was dequeued immediately, the delay was stopped" );
 294                 } )
 295                 .dequeue( "alternate" )
 296
 297                 // stop( "alternate", false ) will NOT clear the queue, so it should automatically dequeue the next
 298                 .stop( "alternate", false, false )
 299
 300                 // this test
 301                 .delay( 1 )
 302                 .queue( function() {
 303                         storage.default1 = true;
 304                         assert.ok( false, "This queue should never run" );
 305                 } )
 306
 307                 // stop( clearQueue ) should clear the queue
 308                 .stop( true, false );
 309
 310         assert.deepEqual( storage, { alt1: true, alt2: true }, "Queue ran the proper functions" );
 311
 312         setTimeout( function() {
 313                 done();
 314         }, 1500 );
 315 } );
 316
 317 QUnit[ includesModule( "effects" ) ? "test" : "skip" ]( "queue stop hooks", function( assert ) {
 318         assert.expect( 2 );
 319         var done = assert.async();
 320         var foo = jQuery( "#foo" );
 321
 322         foo.queue( function( next, hooks ) {
 323                 hooks.stop = function( gotoEnd ) {
 324                         assert.equal( !!gotoEnd, false, "Stopped without gotoEnd" );
 325                 };
 326         } );
 327         foo.stop();
 328
 329         foo.queue( function( next, hooks ) {
 330                 hooks.stop = function( gotoEnd ) {
 331                         assert.equal( gotoEnd, true, "Stopped with gotoEnd" );
 332                         done();
 333                 };
 334         } );
 335
 336         foo.stop( false, true );
 337 } );
 338
 339 } )();