?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Build: replace CRLF with LF during minify
[jquery.git] / test / unit / ajax.js
blob99622c6ced633e19c48b9d72e36423f07c6b2127
1 QUnit.module( "ajax", {
2 afterEach: function() {
3 jQuery( document ).off( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxError ajaxSuccess" );
4 moduleTeardown.apply( this, arguments );
5 }
6 } );
7
8 ( function() {
9 QUnit.test( "Unit Testing Environment", function( assert ) {
10 assert.expect( 2 );
11
12 assert.ok( hasPHP, "Running in an environment with PHP support. The AJAX tests only run if the environment supports PHP!" );
13 assert.ok( !isLocal, "Unit tests are not ran from file:// (especially in Chrome. If you must test from file:// with Chrome, run it with the --allow-file-access-from-files flag!)" );
14 } );
15
16 if ( !includesModule( "ajax" ) || ( isLocal && !hasPHP ) ) {
17 return;
18 }
19
20 function addGlobalEvents( expected, assert ) {
21 return function() {
22 expected = expected || "";
23 jQuery( document ).on( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxError ajaxSuccess", function( e ) {
24 assert.ok( expected.indexOf( e.type ) !== -1, e.type );
25 } );
26 };
27 }
28
29 //----------- jQuery.ajax()
30
31 testIframe(
32 "XMLHttpRequest - Attempt to block tests because of dangling XHR requests (IE)",
33 "ajax/unreleasedXHR.html",
34 function( assert ) {
35 assert.expect( 1 );
36 assert.ok( true, "done" );
37 }
38 );
39
40 ajaxTest( "jQuery.ajax() - success callbacks", 8, function( assert ) {
41 return {
42 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxSuccess", assert ),
43 url: url( "name.html" ),
44 beforeSend: function() {
45 assert.ok( true, "beforeSend" );
46 },
47 success: function() {
48 assert.ok( true, "success" );
49 },
50 complete: function() {
51 assert.ok( true, "complete" );
52 }
53 };
54 } );
55
56 ajaxTest( "jQuery.ajax() - success callbacks - (url, options) syntax", 8, function( assert ) {
57 return {
58 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxSuccess", assert ),
59 create: function( options ) {
60 return jQuery.ajax( url( "name.html" ), options );
61 },
62 beforeSend: function() {
63 assert.ok( true, "beforeSend" );
64 },
65 success: function() {
66 assert.ok( true, "success" );
67 },
68 complete: function() {
69 assert.ok( true, "complete" );
70 }
71 };
72 } );
73
74 jQuery.each( [ " - Same Domain", " - Cross Domain" ], function( crossDomain, label ) {
75 ajaxTest( "jQuery.ajax() - custom attributes for script tag" + label, 5,
76 function( assert ) {
77 return {
78 create: function( options ) {
79 var xhr;
80 options.crossDomain = crossDomain;
81 options.method = "POST";
82 options.dataType = "script";
83 options.scriptAttrs = { id: "jquery-ajax-test", async: "async" };
84 xhr = jQuery.ajax( url( "mock.php?action=script" ), options );
85 assert.equal( jQuery( "#jquery-ajax-test" ).attr( "async" ), "async", "attr value" );
86 return xhr;
87 },
88 beforeSend: function( _jqXhr, settings ) {
89 assert.strictEqual( settings.type, "GET", "Type changed to GET" );
90 },
91 success: function() {
92 assert.ok( true, "success" );
93 },
94 complete: function() {
95 assert.ok( true, "complete" );
96 }
97 };
98 }
99 );
100
101 ajaxTest( "jQuery.ajax() - headers for script transport" + label, 3,
102 function( assert ) {
103 return {
104 create: function( options ) {
105 Globals.register( "corsCallback" );
106 window.corsCallback = function( response ) {
107 assert.strictEqual( response.headers[ "x-custom-test-header" ],
108 "test value", "Custom header sent" );
109 };
110 options.crossDomain = crossDomain;
111 options.dataType = "script";
112 options.headers = { "x-custom-test-header": "test value" };
113 return jQuery.ajax( url( "mock.php?action=script&callback=corsCallback" ), options );
114 },
115 success: function() {
116 assert.ok( true, "success" );
117 },
118 complete: function() {
119 assert.ok( true, "complete" );
120 }
121 };
122 }
123 );
124
125 ajaxTest( "jQuery.ajax() - scriptAttrs winning over headers" + label, 4,
126 function( assert ) {
127 return {
128 create: function( options ) {
129 var xhr;
130 Globals.register( "corsCallback" );
131 window.corsCallback = function( response ) {
132 assert.ok( !response.headers[ "x-custom-test-header" ],
133 "headers losing with scriptAttrs" );
134 };
135 options.crossDomain = crossDomain;
136 options.dataType = "script";
137 options.scriptAttrs = { id: "jquery-ajax-test", async: "async" };
138 options.headers = { "x-custom-test-header": "test value" };
139 xhr = jQuery.ajax( url( "mock.php?action=script&callback=corsCallback" ), options );
140 assert.equal( jQuery( "#jquery-ajax-test" ).attr( "async" ), "async", "attr value" );
141 return xhr;
142 },
143 success: function() {
144 assert.ok( true, "success" );
145 },
146 complete: function() {
147 assert.ok( true, "complete" );
148 }
149 };
150 }
151 );
152 } );
153
154 ajaxTest( "jQuery.ajax() - execute JS when dataType option is provided", 3,
155 function( assert ) {
156 return {
157 create: function( options ) {
158 Globals.register( "corsCallback" );
159 options.crossDomain = true;
160 options.dataType = "script";
161 return jQuery.ajax( url( "mock.php?action=script&header=ecma" ), options );
162 },
163 success: function() {
164 assert.ok( true, "success" );
165 },
166 complete: function() {
167 assert.ok( true, "complete" );
168 }
169 };
170 }
171 );
172
173 jQuery.each( [ " - Same Domain", " - Cross Domain" ], function( crossDomain, label ) {
174 ajaxTest( "jQuery.ajax() - do not execute JS (gh-2432, gh-4822) " + label, 1, function( assert ) {
175 return {
176 url: url( "mock.php?action=script&header" ),
177 crossDomain: crossDomain,
178 success: function() {
179 assert.ok( true, "success" );
180 }
181 };
182 } );
183 } );
184
185 ajaxTest( "jQuery.ajax() - success callbacks (late binding)", 8, function( assert ) {
186 return {
187 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxSuccess", assert ),
188 url: url( "name.html" ),
189 beforeSend: function() {
190 assert.ok( true, "beforeSend" );
191 },
192 success: true,
193 afterSend: function( request ) {
194 request.always( function() {
195 assert.ok( true, "complete" );
196 } ).done( function() {
197 assert.ok( true, "success" );
198 } ).fail( function() {
199 assert.ok( false, "error" );
200 } );
201 }
202 };
203 } );
204
205 ajaxTest( "jQuery.ajax() - success callbacks (oncomplete binding)", 8, function( assert ) {
206 return {
207 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxSuccess", assert ),
208 url: url( "name.html" ),
209 beforeSend: function() {
210 assert.ok( true, "beforeSend" );
211 },
212 success: true,
213 complete: function( xhr ) {
214 xhr.always( function() {
215 assert.ok( true, "complete" );
216 } ).done( function() {
217 assert.ok( true, "success" );
218 } ).fail( function() {
219 assert.ok( false, "error" );
220 } );
221 }
222 };
223 } );
224
225 ajaxTest( "jQuery.ajax() - error callbacks", 8, function( assert ) {
226 return {
227 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxError", assert ),
228 url: url( "mock.php?action=wait&wait=5" ),
229 beforeSend: function() {
230 assert.ok( true, "beforeSend" );
231 },
232 afterSend: function( request ) {
233 request.abort();
234 },
235 error: function() {
236 assert.ok( true, "error" );
237 },
238 complete: function() {
239 assert.ok( true, "complete" );
240 }
241 };
242 } );
243
244 ajaxTest( "jQuery.ajax() - textStatus and errorThrown values", 4, function( assert ) {
245 return [ {
246 url: url( "mock.php?action=wait&wait=5" ),
247 error: function( _, textStatus, errorThrown ) {
248 assert.strictEqual( textStatus, "abort", "textStatus is 'abort' for abort" );
249 assert.strictEqual( errorThrown, "abort", "errorThrown is 'abort' for abort" );
250 },
251 afterSend: function( request ) {
252 request.abort();
253 }
254 },
255 {
256 url: url( "mock.php?action=wait&wait=5" ),
257 error: function( _, textStatus, errorThrown ) {
258 assert.strictEqual( textStatus, "mystatus", "textStatus is 'mystatus' for abort('mystatus')" );
259 assert.strictEqual( errorThrown, "mystatus", "errorThrown is 'mystatus' for abort('mystatus')" );
260 },
261 afterSend: function( request ) {
262 request.abort( "mystatus" );
263 }
264 } ];
265 } );
266
267 ajaxTest( "jQuery.ajax() - responseText on error", 1, function( assert ) {
268 return {
269 url: url( "mock.php?action=error" ),
270 error: function( xhr ) {
271 assert.strictEqual( xhr.responseText, "plain text message", "Test jqXHR.responseText is filled for HTTP errors" );
272 }
273 };
274 } );
275
276 QUnit.test( "jQuery.ajax() - retry with jQuery.ajax( this )", function( assert ) {
277 assert.expect( 2 );
278 var previousUrl,
279 firstTime = true,
280 done = assert.async();
281 jQuery.ajax( {
282 url: url( "mock.php?action=error" ),
283 error: function() {
284 if ( firstTime ) {
285 firstTime = false;
286 jQuery.ajax( this );
287 } else {
288 assert.ok( true, "Test retrying with jQuery.ajax(this) works" );
289 jQuery.ajax( {
290 url: url( "mock.php?action=error&x=2" ),
291 beforeSend: function() {
292 if ( !previousUrl ) {
293 previousUrl = this.url;
294 } else {
295 assert.strictEqual( this.url, previousUrl, "url parameters are not re-appended" );
296 done();
297 return false;
298 }
299 },
300 error: function() {
301 jQuery.ajax( this );
302 }
303 } );
304 }
305 }
306 } );
307 } );
308
309 ajaxTest( "jQuery.ajax() - headers", 8, function( assert ) {
310 return {
311 setup: function() {
312 jQuery( document ).on( "ajaxSend", function( evt, xhr ) {
313 xhr.setRequestHeader( "ajax-send", "test" );
314 } );
315 },
316 url: url( "mock.php?action=headers&keys=siMPle|SometHing-elsE|OthEr|Nullable|undefined|Empty|ajax-send" ),
317 headers: supportjQuery.extend( {
318 "siMPle": "value",
319 "SometHing-elsE": "other value",
320 "OthEr": "something else",
321 "Nullable": null,
322 "undefined": undefined
323
324 // Support: IE 9 - 11+
325 // IE can receive empty headers but not send them.
326 }, QUnit.isIE ? {} : {
327 "Empty": ""
328 } ),
329 success: function( data, _, xhr ) {
330 var i,
331 requestHeaders = jQuery.extend( this.headers, {
332 "ajax-send": "test"
333 } ),
334 tmp = [];
335 for ( i in requestHeaders ) {
336 tmp.push( i, ": ", requestHeaders[ i ] + "", "\n" );
337 }
338 tmp = tmp.join( "" );
339
340 assert.strictEqual( data, tmp, "Headers were sent" );
341 assert.strictEqual( xhr.getResponseHeader( "Sample-Header" ), "Hello World", "Sample header received" );
342 assert.ok( data.indexOf( "undefined" ) < 0, "Undefined header value was not sent" );
343 assert.strictEqual( xhr.getResponseHeader( "Empty-Header" ), "", "Empty header received" );
344 assert.strictEqual( xhr.getResponseHeader( "Sample-Header2" ), "Hello World 2", "Second sample header received" );
345 assert.strictEqual( xhr.getResponseHeader( "List-Header" ), "Item 1, Item 2", "List header received" );
346 assert.strictEqual( xhr.getResponseHeader( "constructor" ), "prototype collision (constructor)", "constructor header received" );
347 assert.strictEqual( xhr.getResponseHeader( "__proto__" ), null, "Undefined __proto__ header not received" );
348 }
349 };
350 } );
351
352 ajaxTest( "jQuery.ajax() - Accept header", 1, function( assert ) {
353 return {
354 url: url( "mock.php?action=headers&keys=accept" ),
355 headers: {
356 Accept: "very wrong accept value"
357 },
358 beforeSend: function( xhr ) {
359 xhr.setRequestHeader( "Accept", "*/*" );
360 },
361 success: function( data ) {
362 assert.strictEqual( data, "accept: */*\n", "Test Accept header is set to last value provided" );
363 }
364 };
365 } );
366
367 ajaxTest( "jQuery.ajax() - contentType", 2, function( assert ) {
368 return [
369 {
370 url: url( "mock.php?action=headers&keys=content-type" ),
371 contentType: "test",
372 success: function( data ) {
373 assert.strictEqual( data, "content-type: test\n", "Test content-type is sent when options.contentType is set" );
374 }
375 },
376 {
377 url: url( "mock.php?action=headers&keys=content-type" ),
378 contentType: false,
379 success: function( data ) {
380
381 // Some server/interpreter combinations always supply a Content-Type to scripts
382 data = data || "content-type: \n";
383 assert.strictEqual( data, "content-type: \n", "Test content-type is not set when options.contentType===false" );
384 }
385 }
386 ];
387 } );
388
389 ajaxTest( "jQuery.ajax() - protocol-less urls", 1, function( assert ) {
390 return {
391 url: "//somedomain.com",
392 beforeSend: function( xhr, settings ) {
393 assert.equal( settings.url, location.protocol + "//somedomain.com", "Make sure that the protocol is added." );
394 return false;
395 },
396 error: true
397 };
398 } );
399
400 ajaxTest( "jQuery.ajax() - URL fragment component preservation", 5, function( assert ) {
401 return [
402 {
403 url: baseURL + "name.html#foo",
404 beforeSend: function( xhr, settings ) {
405 assert.equal( settings.url, baseURL + "name.html#foo",
406 "hash preserved for request with no query component." );
407 return false;
408 },
409 error: true
410 },
411 {
412 url: baseURL + "name.html?abc#foo",
413 beforeSend: function( xhr, settings ) {
414 assert.equal( settings.url, baseURL + "name.html?abc#foo",
415 "hash preserved for request with query component." );
416 return false;
417 },
418 error: true
419 },
420 {
421 url: baseURL + "name.html?abc#foo",
422 data: {
423 "test": 123
424 },
425 beforeSend: function( xhr, settings ) {
426 assert.equal( settings.url, baseURL + "name.html?abc&test=123#foo",
427 "hash preserved for request with query component and data." );
428 return false;
429 },
430 error: true
431 },
432 {
433 url: baseURL + "name.html?abc#foo",
434 data: [
435 {
436 name: "test",
437 value: 123
438 },
439 {
440 name: "devo",
441 value: "hat"
442 }
443 ],
444 beforeSend: function( xhr, settings ) {
445 assert.equal( settings.url, baseURL + "name.html?abc&test=123&devo=hat#foo",
446 "hash preserved for request with query component and array data." );
447 return false;
448 },
449 error: true
450 },
451 {
452 url: baseURL + "name.html?abc#brownies",
453 data: {
454 "devo": "hat"
455 },
456 cache: false,
457 beforeSend: function( xhr, settings ) {
458 // Clear the cache-buster param value
459 var url = settings.url.replace( /_=[^&#]+/, "_=" );
460 assert.equal( url, baseURL + "name.html?abc&devo=hat&_=#brownies",
461 "hash preserved for cache-busting request with query component and data." );
462 return false;
463 },
464 error: true
465 }
466 ];
467 } );
468
469 ajaxTest( "jQuery.ajax() - traditional param encoding", 4, function( assert ) {
470 return [
471 {
472 url: "/",
473 traditional: true,
474 data: {
475 "devo": "hat",
476 "answer": 42,
477 "quux": "a space"
478 },
479 beforeSend: function( xhr, settings ) {
480 assert.equal( settings.url, "/?devo=hat&answer=42&quux=a%20space", "Simple case" );
481 return false;
482 },
483 error: true
484 },
485 {
486 url: "/",
487 traditional: true,
488 data: {
489 "a": [ 1, 2, 3 ],
490 "b[]": [ "b1", "b2" ]
491 },
492 beforeSend: function( xhr, settings ) {
493 assert.equal( settings.url, "/?a=1&a=2&a=3&b%5B%5D=b1&b%5B%5D=b2", "Arrays" );
494 return false;
495 },
496 error: true
497 },
498 {
499 url: "/",
500 traditional: true,
501 data: {
502 "a": [ [ 1, 2 ], [ 3, 4 ], 5 ]
503 },
504 beforeSend: function( xhr, settings ) {
505 assert.equal( settings.url, "/?a=1%2C2&a=3%2C4&a=5", "Nested arrays" );
506 return false;
507 },
508 error: true
509 },
510 {
511 url: "/",
512 traditional: true,
513 data: {
514 "a": [ "w", [ [ "x", "y" ], "z" ] ]
515 },
516 cache: false,
517 beforeSend: function( xhr, settings ) {
518 var url = settings.url.replace( /\d{3,}/, "" );
519 assert.equal( url, "/?a=w&a=x%2Cy%2Cz&_=", "Cache-buster" );
520 return false;
521 },
522 error: true
523 }
524 ];
525 } );
526
527 ajaxTest( "jQuery.ajax() - cross-domain detection", 8, function( assert ) {
528 function request( url, title, crossDomainOrOptions ) {
529 return jQuery.extend( {
530 dataType: "jsonp",
531 url: url,
532 beforeSend: function( _, s ) {
533 assert.ok( crossDomainOrOptions === false ? !s.crossDomain : s.crossDomain, title );
534 return false;
535 },
536 error: true
537 }, crossDomainOrOptions );
538 }
539
540 var loc = document.location,
541 samePort = loc.port || ( loc.protocol === "http:" ? 80 : 443 ),
542 otherPort = loc.port === 666 ? 667 : 666,
543 otherProtocol = loc.protocol === "http:" ? "https:" : "http:";
544
545 return [
546 request(
547 loc.protocol + "//" + loc.hostname + ":" + samePort,
548 "Test matching ports are not detected as cross-domain",
549 false
550 ),
551 request(
552 otherProtocol + "//" + loc.host,
553 "Test different protocols are detected as cross-domain"
554 ),
555 request(
556 "app:/path",
557 "Adobe AIR app:/ URL detected as cross-domain"
558 ),
559 request(
560 loc.protocol + "//example.invalid:" + ( loc.port || 80 ),
561 "Test different hostnames are detected as cross-domain"
562 ),
563 request(
564 loc.protocol + "//" + loc.hostname + ":" + otherPort,
565 "Test different ports are detected as cross-domain"
566 ),
567 request(
568 "about:blank",
569 "Test about:blank is detected as cross-domain"
570 ),
571 request(
572 loc.protocol + "//" + loc.host,
573 "Test forced crossDomain is detected as cross-domain",
574 {
575 crossDomain: true
576 }
577 ),
578 request(
579 " https://otherdomain.com",
580 "Cross-domain url with leading space is detected as cross-domain"
581 )
582 ];
583 } );
584
585 ajaxTest( "jQuery.ajax() - abort", 9, function( assert ) {
586 return {
587 setup: addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxError ajaxComplete", assert ),
588 url: url( "mock.php?action=wait&wait=5" ),
589 beforeSend: function() {
590 assert.ok( true, "beforeSend" );
591 },
592 afterSend: function( xhr ) {
593 assert.strictEqual( xhr.readyState, 1, "XHR readyState indicates successful dispatch" );
594 xhr.abort();
595 assert.strictEqual( xhr.readyState, 0, "XHR readyState indicates successful abortion" );
596 },
597 error: true,
598 complete: function() {
599 assert.ok( true, "complete" );
600 }
601 };
602 } );
603
604 ajaxTest( "jQuery.ajax() - native abort", 2, function( assert ) {
605 return {
606 url: url( "mock.php?action=wait&wait=1" ),
607 xhr: function() {
608 var xhr = new window.XMLHttpRequest();
609 setTimeout( function() {
610 xhr.abort();
611 }, 100 );
612 return xhr;
613 },
614 error: function( xhr, msg ) {
615 assert.strictEqual( msg, "error", "Native abort triggers error callback" );
616 },
617 complete: function() {
618 assert.ok( true, "complete" );
619 }
620 };
621 } );
622
623 ajaxTest( "jQuery.ajax() - native timeout", 2, function( assert ) {
624 return {
625 url: url( "mock.php?action=wait&wait=1" ),
626 xhr: function() {
627 var xhr = new window.XMLHttpRequest();
628 xhr.timeout = 1;
629 return xhr;
630 },
631 error: function( xhr, msg ) {
632 assert.strictEqual( msg, "error", "Native timeout triggers error callback" );
633 },
634 complete: function() {
635 assert.ok( true, "complete" );
636 }
637 };
638 } );
639
640 ajaxTest( "jQuery.ajax() - events with context", 12, function( assert ) {
641 var context = document.createElement( "div" );
642
643 function event( e ) {
644 assert.equal( this, context, e.type );
645 }
646
647 function callback( msg ) {
648 return function() {
649 assert.equal( this, context, "context is preserved on callback " + msg );
650 };
651 }
652
653 return {
654 setup: function() {
655 jQuery( context ).appendTo( "#foo" )
656 .on( "ajaxSend", event )
657 .on( "ajaxComplete", event )
658 .on( "ajaxError", event )
659 .on( "ajaxSuccess", event );
660 },
661 requests: [ {
662 url: url( "name.html" ),
663 context: context,
664 beforeSend: callback( "beforeSend" ),
665 success: callback( "success" ),
666 complete: callback( "complete" )
667 }, {
668 url: url( "404.txt" ),
669 context: context,
670 beforeSend: callback( "beforeSend" ),
671 error: callback( "error" ),
672 complete: callback( "complete" )
673 } ]
674 };
675 } );
676
677 ajaxTest( "jQuery.ajax() - events without context", 3, function( assert ) {
678 function nocallback( msg ) {
679 return function() {
680 assert.equal( typeof this.url, "string", "context is settings on callback " + msg );
681 };
682 }
683 return {
684 url: url( "404.txt" ),
685 beforeSend: nocallback( "beforeSend" ),
686 error: nocallback( "error" ),
687 complete: nocallback( "complete" )
688 };
689 } );
690
691 ajaxTest( "trac-15118 - jQuery.ajax() - function without jQuery.event", 1, function( assert ) {
692 var holder;
693 return {
694 url: url( "mock.php?action=json" ),
695 setup: function() {
696 holder = jQuery.event;
697 delete jQuery.event;
698 },
699 complete: function() {
700 assert.ok( true, "Call can be made without jQuery.event" );
701 jQuery.event = holder;
702 },
703 success: true
704 };
705 } );
706
707 ajaxTest( "trac-15160 - jQuery.ajax() - request manually aborted in ajaxSend", 3, function( assert ) {
708 return {
709 setup: function() {
710 jQuery( document ).on( "ajaxSend", function( e, jqXHR ) {
711 jqXHR.abort();
712 } );
713
714 jQuery( document ).on( "ajaxError ajaxComplete", function( e, jqXHR ) {
715 assert.equal( jqXHR.statusText, "abort", "jqXHR.statusText equals abort on global ajaxComplete and ajaxError events" );
716 } );
717 },
718 url: url( "name.html" ),
719 error: true,
720 complete: function() {
721 assert.ok( true, "complete" );
722 }
723 };
724 } );
725
726 ajaxTest( "jQuery.ajax() - context modification", 1, function( assert ) {
727 return {
728 url: url( "name.html" ),
729 context: {},
730 beforeSend: function() {
731 this.test = "foo";
732 },
733 afterSend: function() {
734 assert.strictEqual( this.context.test, "foo", "Make sure the original object is maintained." );
735 },
736 success: true
737 };
738 } );
739
740 ajaxTest( "jQuery.ajax() - context modification through ajaxSetup", 3, function( assert ) {
741 var obj = {};
742 return {
743 setup: function() {
744 jQuery.ajaxSetup( {
745 context: obj
746 } );
747 assert.strictEqual( jQuery.ajaxSettings.context, obj, "Make sure the context is properly set in ajaxSettings." );
748 },
749 requests: [ {
750 url: url( "name.html" ),
751 success: function() {
752 assert.strictEqual( this, obj, "Make sure the original object is maintained." );
753 }
754 }, {
755 url: url( "name.html" ),
756 context: {},
757 success: function() {
758 assert.ok( this !== obj, "Make sure overriding context is possible." );
759 }
760 } ]
761 };
762 } );
763
764 ajaxTest( "jQuery.ajax() - disabled globals", 3, function( assert ) {
765 return {
766 setup: addGlobalEvents( "", assert ),
767 global: false,
768 url: url( "name.html" ),
769 beforeSend: function() {
770 assert.ok( true, "beforeSend" );
771 },
772 success: function() {
773 assert.ok( true, "success" );
774 },
775 complete: function() {
776 assert.ok( true, "complete" );
777 }
778 };
779 } );
780
781 ajaxTest( "jQuery.ajax() - xml: non-namespace elements inside namespaced elements", 3, function( assert ) {
782 return {
783 url: url( "with_fries.xml" ),
784 dataType: "xml",
785 success: function( resp ) {
786 assert.equal( jQuery( "properties", resp ).length, 1, "properties in responseXML" );
787 assert.equal( jQuery( "jsconf", resp ).length, 1, "jsconf in responseXML" );
788 assert.equal( jQuery( "thing", resp ).length, 2, "things in responseXML" );
789 }
790 };
791 } );
792
793 ajaxTest( "jQuery.ajax() - xml: non-namespace elements inside namespaced elements (over JSONP)", 3, function( assert ) {
794 return {
795 url: url( "mock.php?action=xmlOverJsonp" ),
796 dataType: "jsonp xml",
797 success: function( resp ) {
798 assert.equal( jQuery( "properties", resp ).length, 1, "properties in responseXML" );
799 assert.equal( jQuery( "jsconf", resp ).length, 1, "jsconf in responseXML" );
800 assert.equal( jQuery( "thing", resp ).length, 2, "things in responseXML" );
801 }
802 };
803 } );
804
805 ajaxTest( "jQuery.ajax() - HEAD requests", 2, function( assert ) {
806 return [
807 {
808 url: url( "name.html" ),
809 type: "HEAD",
810 success: function( data, status, xhr ) {
811 assert.ok( /Date/i.test( xhr.getAllResponseHeaders() ), "No Date in HEAD response" );
812 }
813 },
814 {
815 url: url( "name.html" ),
816 data: {
817 "whip_it": "good"
818 },
819 type: "HEAD",
820 success: function( data, status, xhr ) {
821 assert.ok( /Date/i.test( xhr.getAllResponseHeaders() ), "No Date in HEAD response with data" );
822 }
823 }
824 ];
825 } );
826
827 ajaxTest( "jQuery.ajax() - beforeSend", 1, function( assert ) {
828 return {
829 url: url( "name.html" ),
830 beforeSend: function() {
831 this.check = true;
832 },
833 success: function() {
834 assert.ok( this.check, "check beforeSend was executed" );
835 }
836 };
837 } );
838
839 ajaxTest( "jQuery.ajax() - beforeSend, cancel request manually", 2, function( assert ) {
840 return {
841 create: function() {
842 return jQuery.ajax( {
843 url: url( "name.html" ),
844 beforeSend: function( xhr ) {
845 assert.ok( true, "beforeSend got called, canceling" );
846 xhr.abort();
847 },
848 success: function() {
849 assert.ok( false, "request didn't get canceled" );
850 },
851 complete: function() {
852 assert.ok( false, "request didn't get canceled" );
853 },
854 error: function() {
855 assert.ok( false, "request didn't get canceled" );
856 }
857 } );
858 },
859 fail: function( _, reason ) {
860 assert.strictEqual( reason, "canceled", "canceled request must fail with 'canceled' status text" );
861 }
862 };
863 } );
864
865 ajaxTest( "jQuery.ajax() - dataType html", 5, function( assert ) {
866 return {
867 setup: function() {
868 Globals.register( "testFoo" );
869 Globals.register( "testBar" );
870 },
871 dataType: "html",
872 url: url( "mock.php?action=testHTML&baseURL=" + baseURL ),
873 success: function( data ) {
874 assert.ok( data.match( /^html text/ ), "Check content for datatype html" );
875 jQuery( "#ap" ).html( data );
876 assert.strictEqual( window[ "testFoo" ], "foo", "Check if script was evaluated for datatype html" );
877 assert.strictEqual( window[ "testBar" ], "bar", "Check if script src was evaluated for datatype html" );
878 }
879 };
880 } );
881
882 ajaxTest( "jQuery.ajax() - do execute scripts if JSONP from unsuccessful responses", 1, function( assert ) {
883 var testMsg = "Unsuccessful JSONP requests should have a JSON body";
884 return {
885 dataType: "jsonp",
886 url: url( "mock.php?action=errorWithScript" ),
887 // error is the significant assertion
888 error: function( xhr ) {
889 var expected = { "status": 404, "msg": "Not Found" };
890 assert.deepEqual( xhr.responseJSON, expected, testMsg );
891 }
892 };
893 } );
894
895 ajaxTest( "jQuery.ajax() - do not execute scripts from unsuccessful responses (gh-4250)", 11, function( assert ) {
896 var globalEval = jQuery.globalEval;
897
898 var failConverters = {
899 "text script": function() {
900 assert.ok( false, "No converter for unsuccessful response" );
901 }
902 };
903
904 function request( title, options ) {
905 var testMsg = title + ": expected file missing status";
906 return jQuery.extend( {
907 beforeSend: function() {
908 jQuery.globalEval = function() {
909 assert.ok( false, "Should not eval" );
910 };
911 },
912 complete: function() {
913 jQuery.globalEval = globalEval;
914 },
915 // error is the significant assertion
916 error: function( xhr ) {
917 assert.strictEqual( xhr.status, 404, testMsg );
918 },
919 success: function() {
920 assert.ok( false, "Unanticipated success" );
921 }
922 }, options );
923 }
924
925 return [
926 request(
927 "HTML reply",
928 {
929 url: url( "404.txt" )
930 }
931 ),
932 request(
933 "HTML reply with dataType",
934 {
935 dataType: "script",
936 url: url( "404.txt" )
937 }
938 ),
939 request(
940 "script reply",
941 {
942 url: url( "mock.php?action=errorWithScript&withScriptContentType" )
943 }
944 ),
945 request(
946 "non-script reply",
947 {
948 url: url( "mock.php?action=errorWithScript" )
949 }
950 ),
951 request(
952 "script reply with dataType",
953 {
954 dataType: "script",
955 url: url( "mock.php?action=errorWithScript&withScriptContentType" )
956 }
957 ),
958 request(
959 "non-script reply with dataType",
960 {
961 dataType: "script",
962 url: url( "mock.php?action=errorWithScript" )
963 }
964 ),
965 request(
966 "script reply with converter",
967 {
968 converters: failConverters,
969 url: url( "mock.php?action=errorWithScript&withScriptContentType" )
970 }
971 ),
972 request(
973 "non-script reply with converter",
974 {
975 converters: failConverters,
976 url: url( "mock.php?action=errorWithScript" )
977 }
978 ),
979 request(
980 "script reply with converter and dataType",
981 {
982 converters: failConverters,
983 dataType: "script",
984 url: url( "mock.php?action=errorWithScript&withScriptContentType" )
985 }
986 ),
987 request(
988 "non-script reply with converter and dataType",
989 {
990 converters: failConverters,
991 dataType: "script",
992 url: url( "mock.php?action=errorWithScript" )
993 }
994 ),
995 request(
996 "JSONP reply with dataType",
997 {
998 dataType: "jsonp",
999 url: url( "mock.php?action=errorWithScript" ),
1000 beforeSend: function() {
1001 jQuery.globalEval = function( response ) {
1002 assert.ok( /"status": 404, "msg": "Not Found"/.test( response ), "Error object returned" );
1003 };
1004 }
1005 }
1006 )
1007 ];
1008 } );
1009
1010 ajaxTest( "jQuery.ajax() - synchronous request", 1, function( assert ) {
1011 return {
1012 url: url( "json_obj.js" ),
1013 dataType: "text",
1014 async: false,
1015 success: true,
1016 afterSend: function( xhr ) {
1017 assert.ok( /^\{ "data"/.test( xhr.responseText ), "check returned text" );
1018 }
1019 };
1020 } );
1021
1022 ajaxTest( "jQuery.ajax() - synchronous request with callbacks", 2, function( assert ) {
1023 return {
1024 url: url( "json_obj.js" ),
1025 async: false,
1026 dataType: "text",
1027 success: true,
1028 afterSend: function( xhr ) {
1029 var result;
1030 xhr.done( function( data ) {
1031 assert.ok( true, "success callback executed" );
1032 result = data;
1033 } );
1034 assert.ok( /^\{ "data"/.test( result ), "check returned text" );
1035 }
1036 };
1037 } );
1038
1039 QUnit.test( "jQuery.ajax(), jQuery.get[Script|JSON](), jQuery.post(), pass-through request object", function( assert ) {
1040 assert.expect( 8 );
1041 var done = assert.async();
1042 var target = "name.html",
1043 successCount = 0,
1044 errorCount = 0,
1045 errorEx = "",
1046 success = function() {
1047 successCount++;
1048 };
1049 jQuery( document ).on( "ajaxError.passthru", function( e, xml ) {
1050 errorCount++;
1051 errorEx += ": " + xml.status;
1052 } );
1053 jQuery( document ).one( "ajaxStop", function() {
1054 assert.equal( successCount, 5, "Check all ajax calls successful" );
1055 assert.equal( errorCount, 0, "Check no ajax errors (status" + errorEx + ")" );
1056 jQuery( document ).off( "ajaxError.passthru" );
1057 done();
1058 } );
1059 Globals.register( "testBar" );
1060
1061 assert.ok( jQuery.get( url( target ), success ), "get" );
1062 assert.ok( jQuery.post( url( target ), success ), "post" );
1063 assert.ok( jQuery.getScript( url( "mock.php?action=testbar" ), success ), "script" );
1064 assert.ok( jQuery.getJSON( url( "json_obj.js" ), success ), "json" );
1065 assert.ok( jQuery.ajax( {
1066 url: url( target ),
1067 success: success
1068 } ), "generic" );
1069 } );
1070
1071 ajaxTest( "jQuery.ajax() - cache", 28, function( assert ) {
1072 var re = /_=(.*?)(&|$)/g,
1073 rootUrl = baseURL + "text.txt";
1074
1075 function request( url, title ) {
1076 return {
1077 url: url,
1078 cache: false,
1079 beforeSend: function() {
1080 var parameter, tmp;
1081
1082 // URL sanity check
1083 assert.equal( this.url.indexOf( rootUrl ), 0, "root url not mangled: " + this.url );
1084 assert.equal( /\&.*\?/.test( this.url ), false, "parameter delimiters in order" );
1085
1086 while ( ( tmp = re.exec( this.url ) ) ) {
1087 assert.strictEqual( parameter, undefined, title + ": only one 'no-cache' parameter" );
1088 parameter = tmp[ 1 ];
1089 assert.notStrictEqual( parameter, "tobereplaced555", title + ": parameter (if it was there) was replaced" );
1090 }
1091 return false;
1092 },
1093 error: true
1094 };
1095 }
1096
1097 return [
1098 request(
1099 rootUrl,
1100 "no query"
1101 ),
1102 request(
1103 rootUrl + "?",
1104 "empty query"
1105 ),
1106 request(
1107 rootUrl + "?pizza=true",
1108 "1 parameter"
1109 ),
1110 request(
1111 rootUrl + "?_=tobereplaced555",
1112 "_= parameter"
1113 ),
1114 request(
1115 rootUrl + "?pizza=true&_=tobereplaced555",
1116 "1 parameter and _="
1117 ),
1118 request(
1119 rootUrl + "?_=tobereplaced555&tv=false",
1120 "_= and 1 parameter"
1121 ),
1122 request(
1123 rootUrl + "?name=David&_=tobereplaced555&washere=true",
1124 "2 parameters surrounding _="
1125 )
1126 ];
1127 } );
1128
1129 jQuery.each( [ " - Same Domain", " - Cross Domain" ], function( crossDomain, label ) {
1130
1131 ajaxTest( "jQuery.ajax() - JSONP - Query String (?n)" + label, 4, function( assert ) {
1132 return [
1133 {
1134 url: baseURL + "mock.php?action=jsonp&callback=?",
1135 dataType: "jsonp",
1136 crossDomain: crossDomain,
1137 success: function( data ) {
1138 assert.ok( data.data, "JSON results returned (GET, url callback)" );
1139 }
1140 },
1141 {
1142 url: baseURL + "mock.php?action=jsonp&callback=??",
1143 dataType: "jsonp",
1144 crossDomain: crossDomain,
1145 success: function( data ) {
1146 assert.ok( data.data, "JSON results returned (GET, url context-free callback)" );
1147 }
1148 },
1149 {
1150 url: baseURL + "mock.php/???action=jsonp",
1151 dataType: "jsonp",
1152 crossDomain: crossDomain,
1153 success: function( data ) {
1154 assert.ok( data.data, "JSON results returned (GET, REST-like)" );
1155 }
1156 },
1157 {
1158 url: baseURL + "mock.php/???action=jsonp&array=1",
1159 dataType: "jsonp",
1160 crossDomain: crossDomain,
1161 success: function( data ) {
1162 assert.ok( Array.isArray( data ), "JSON results returned (GET, REST-like with param)" );
1163 }
1164 }
1165 ];
1166 } );
1167
1168 ajaxTest( "jQuery.ajax() - JSONP - Explicit callback param" + label, 10, function( assert ) {
1169 return {
1170 setup: function() {
1171 Globals.register( "functionToCleanUp" );
1172 Globals.register( "XXX" );
1173 Globals.register( "jsonpResults" );
1174 window[ "jsonpResults" ] = function( data ) {
1175 assert.ok( data[ "data" ], "JSON results returned (GET, custom callback function)" );
1176 };
1177 },
1178 requests: [ {
1179 url: baseURL + "mock.php?action=jsonp",
1180 dataType: "jsonp",
1181 crossDomain: crossDomain,
1182 jsonp: "callback",
1183 success: function( data ) {
1184 assert.ok( data[ "data" ], "JSON results returned (GET, data obj callback)" );
1185 }
1186 }, {
1187 url: baseURL + "mock.php?action=jsonp",
1188 dataType: "jsonp",
1189 crossDomain: crossDomain,
1190 jsonpCallback: "jsonpResults",
1191 success: function( data ) {
1192 assert.strictEqual(
1193 typeof window[ "jsonpResults" ],
1194 "function",
1195 "should not rewrite original function"
1196 );
1197 assert.ok( data.data, "JSON results returned (GET, custom callback name)" );
1198 }
1199 }, {
1200 url: baseURL + "mock.php?action=jsonp",
1201 dataType: "jsonp",
1202 crossDomain: crossDomain,
1203 jsonpCallback: "functionToCleanUp",
1204 success: function( data ) {
1205 assert.ok( data[ "data" ], "JSON results returned (GET, custom callback name to be cleaned up)" );
1206 assert.strictEqual( window[ "functionToCleanUp" ], true, "Callback was removed (GET, custom callback name to be cleaned up)" );
1207 var xhr;
1208 jQuery.ajax( {
1209 url: baseURL + "mock.php?action=jsonp",
1210 dataType: "jsonp",
1211 crossDomain: crossDomain,
1212 jsonpCallback: "functionToCleanUp",
1213 beforeSend: function( jqXHR ) {
1214 xhr = jqXHR;
1215 return false;
1216 }
1217 } );
1218 xhr.fail( function() {
1219 assert.ok( true, "Ajax error JSON (GET, custom callback name to be cleaned up)" );
1220 assert.strictEqual( window[ "functionToCleanUp" ], true, "Callback was removed after early abort (GET, custom callback name to be cleaned up)" );
1221 } );
1222 }
1223 }, {
1224 url: baseURL + "mock.php?action=jsonp&callback=XXX",
1225 dataType: "jsonp",
1226 jsonp: false,
1227 jsonpCallback: "XXX",
1228 crossDomain: crossDomain,
1229 beforeSend: function() {
1230 assert.ok( /action=jsonp&callback=XXX&_=\d+$/.test( this.url ), "The URL wasn't messed with (GET, custom callback name with no url manipulation)" );
1231 },
1232 success: function( data ) {
1233 assert.ok( data[ "data" ], "JSON results returned (GET, custom callback name with no url manipulation)" );
1234 }
1235 } ]
1236 };
1237 } );
1238
1239 ajaxTest( "jQuery.ajax() - JSONP - Callback in data" + label, 2, function( assert ) {
1240 return [
1241 {
1242 url: baseURL + "mock.php?action=jsonp",
1243 dataType: "jsonp",
1244 crossDomain: crossDomain,
1245 data: "callback=?",
1246 success: function( data ) {
1247 assert.ok( data.data, "JSON results returned (GET, data callback)" );
1248 }
1249 },
1250 {
1251 url: baseURL + "mock.php?action=jsonp",
1252 dataType: "jsonp",
1253 crossDomain: crossDomain,
1254 data: "callback=??",
1255 success: function( data ) {
1256 assert.ok( data.data, "JSON results returned (GET, data context-free callback)" );
1257 }
1258 }
1259 ];
1260 } );
1261
1262 ajaxTest( "jQuery.ajax() - JSONP - POST" + label, 3, function( assert ) {
1263 return [
1264 {
1265 type: "POST",
1266 url: baseURL + "mock.php?action=jsonp",
1267 dataType: "jsonp",
1268 crossDomain: crossDomain,
1269 success: function( data ) {
1270 assert.ok( data[ "data" ], "JSON results returned (POST, no callback)" );
1271 }
1272 },
1273 {
1274 type: "POST",
1275 url: baseURL + "mock.php?action=jsonp",
1276 data: "callback=?",
1277 dataType: "jsonp",
1278 crossDomain: crossDomain,
1279 success: function( data ) {
1280 assert.ok( data[ "data" ], "JSON results returned (POST, data callback)" );
1281 }
1282 },
1283 {
1284 type: "POST",
1285 url: baseURL + "mock.php?action=jsonp",
1286 jsonp: "callback",
1287 dataType: "jsonp",
1288 crossDomain: crossDomain,
1289 success: function( data ) {
1290 assert.ok( data[ "data" ], "JSON results returned (POST, data obj callback)" );
1291 }
1292 }
1293 ];
1294 } );
1295
1296 ajaxTest( "jQuery.ajax() - JSONP" + label, 3, function( assert ) {
1297 return [
1298 {
1299 url: baseURL + "mock.php?action=jsonp",
1300 dataType: "jsonp",
1301 crossDomain: crossDomain,
1302 success: function( data ) {
1303 assert.ok( data.data, "JSON results returned (GET, no callback)" );
1304 }
1305 },
1306 {
1307 create: function( options ) {
1308 var request = jQuery.ajax( options ),
1309 promise = request.then( function( data ) {
1310 assert.ok( data.data, "first request: JSON results returned (GET, no callback)" );
1311 request = jQuery.ajax( this ).done( function( data ) {
1312 assert.ok( data.data, "this re-used: JSON results returned (GET, no callback)" );
1313 } );
1314 promise.abort = request.abort;
1315 return request;
1316 } );
1317 promise.abort = request.abort;
1318 return promise;
1319 },
1320 url: baseURL + "mock.php?action=jsonp",
1321 dataType: "jsonp",
1322 crossDomain: crossDomain,
1323 success: true
1324 }
1325 ];
1326 } );
1327
1328 ajaxTest( "jQuery.ajax() - no JSONP auto-promotion" + label, 4, function( assert ) {
1329 return [
1330 {
1331 url: baseURL + "mock.php?action=jsonp",
1332 dataType: "json",
1333 crossDomain: crossDomain,
1334 success: function() {
1335 assert.ok( false, "JSON parsing should have failed (no callback)" );
1336 },
1337 fail: function() {
1338 assert.ok( true, "JSON parsing failed, JSONP not used (no callback)" );
1339 }
1340 },
1341 {
1342 url: baseURL + "mock.php?action=jsonp&callback=?",
1343 dataType: "json",
1344 crossDomain: crossDomain,
1345 success: function() {
1346 assert.ok( false, "JSON parsing should have failed (ULR callback)" );
1347 },
1348 fail: function() {
1349 assert.ok( true, "JSON parsing failed, JSONP not used (URL callback)" );
1350 }
1351 },
1352 {
1353 url: baseURL + "mock.php?action=jsonp",
1354 dataType: "json",
1355 crossDomain: crossDomain,
1356 data: "callback=?",
1357 success: function() {
1358 assert.ok( false, "JSON parsing should have failed (data callback=?)" );
1359 },
1360 fail: function() {
1361 assert.ok( true, "JSON parsing failed, JSONP not used (data callback=?)" );
1362 }
1363 },
1364 {
1365 url: baseURL + "mock.php?action=jsonp",
1366 dataType: "json",
1367 crossDomain: crossDomain,
1368 data: "callback=??",
1369 success: function() {
1370 assert.ok( false, "JSON parsing should have failed (data callback=??)" );
1371 },
1372 fail: function() {
1373 assert.ok( true, "JSON parsing failed, JSONP not used (data callback=??)" );
1374 }
1375 }
1376 ];
1377 } );
1378
1379 ajaxTest( "jQuery.ajax() - JSON - no ? replacement" + label, 9, function( assert ) {
1380 return [
1381 {
1382 url: baseURL + "mock.php?action=json&callback=?",
1383 dataType: "json",
1384 crossDomain: crossDomain,
1385 beforeSend: function( _jqXhr, settings ) {
1386 var queryString = settings.url.replace( /^[^?]*\?/, "" );
1387 assert.ok(
1388 queryString.indexOf( "jQuery" ) === -1,
1389 "jQuery callback not inserted into the URL (URL callback)"
1390 );
1391 assert.ok(
1392 queryString.indexOf( "callback=?" ) > -1,
1393 "\"callback=?\" present in the URL unchanged (URL callback)"
1394 );
1395 },
1396 success: function( data ) {
1397 assert.ok( data.data, "JSON results returned (URL callback)" );
1398 }
1399 },
1400 {
1401 url: baseURL + "mock.php?action=json",
1402 dataType: "json",
1403 crossDomain: crossDomain,
1404 data: "callback=?",
1405 beforeSend: function( _jqXhr, settings ) {
1406 var queryString = settings.url.replace( /^[^?]*\?/, "" );
1407 assert.ok(
1408 queryString.indexOf( "jQuery" ) === -1,
1409 "jQuery callback not inserted into the URL (data callback=?)"
1410 );
1411 assert.ok(
1412 queryString.indexOf( "callback=?" ) > -1,
1413 "\"callback=?\" present in the URL unchanged (data callback=?)"
1414 );
1415 },
1416 success: function( data ) {
1417 assert.ok( data.data, "JSON results returned (data callback=?)" );
1418 }
1419 },
1420 {
1421 url: baseURL + "mock.php?action=json",
1422 dataType: "json",
1423 crossDomain: crossDomain,
1424 data: "callback=??",
1425 beforeSend: function( _jqXhr, settings ) {
1426 var queryString = settings.url.replace( /^[^?]*\?/, "" );
1427 assert.ok(
1428 queryString.indexOf( "jQuery" ) === -1,
1429 "jQuery callback not inserted into the URL (data callback=??)"
1430 );
1431 assert.ok(
1432 queryString.indexOf( "callback=??" ) > -1,
1433 "\"callback=?\" present in the URL unchanged (data callback=??)"
1434 );
1435 },
1436 success: function( data ) {
1437 assert.ok( data.data, "JSON results returned (data callback=??)" );
1438 }
1439 }
1440 ];
1441 } );
1442
1443 } );
1444
1445 testIframe(
1446 "jQuery.ajax() - script, CSP script-src compat (gh-3969)",
1447 "mock.php?action=cspAjaxScript",
1448 function( assert, jQuery, window, document, type, downloadedScriptCalled ) {
1449 assert.expect( 2 );
1450
1451 assert.strictEqual( type, "GET", "Type changed to GET" );
1452 assert.strictEqual( downloadedScriptCalled, true, "External script called" );
1453 }
1454 );
1455
1456 ajaxTest( "jQuery.ajax() - script, Remote", 2, function( assert ) {
1457 return {
1458 setup: function() {
1459 Globals.register( "testBar" );
1460 },
1461 url: url( "mock.php?action=testbar" ),
1462 dataType: "script",
1463 success: function() {
1464 assert.strictEqual( window[ "testBar" ], "bar", "Script results returned (GET, no callback)" );
1465 }
1466 };
1467 } );
1468
1469 ajaxTest( "jQuery.ajax() - script, Remote with POST", 4, function( assert ) {
1470 return {
1471 setup: function() {
1472 Globals.register( "testBar" );
1473 },
1474 url: url( "mock.php?action=testbar" ),
1475 beforeSend: function( _jqXhr, settings ) {
1476 assert.strictEqual( settings.type, "GET", "Type changed to GET" );
1477 },
1478 type: "POST",
1479 dataType: "script",
1480 success: function( data, status ) {
1481 assert.strictEqual( window[ "testBar" ], "bar", "Script results returned (POST, no callback)" );
1482 assert.strictEqual( status, "success", "Script results returned (POST, no callback)" );
1483 }
1484 };
1485 } );
1486
1487 ajaxTest( "jQuery.ajax() - script, Remote with scheme-less URL", 2, function( assert ) {
1488 return {
1489 setup: function() {
1490 Globals.register( "testBar" );
1491 },
1492 url: url( "mock.php?action=testbar" ),
1493 dataType: "script",
1494 success: function() {
1495 assert.strictEqual( window[ "testBar" ], "bar", "Script results returned (GET, no callback)" );
1496 }
1497 };
1498 } );
1499
1500 ajaxTest( "jQuery.ajax() - malformed JSON", 2, function( assert ) {
1501 return {
1502 url: baseURL + "badjson.js",
1503 dataType: "json",
1504 error: function( xhr, msg, detailedMsg ) {
1505 assert.strictEqual( msg, "parsererror", "A parse error occurred." );
1506 assert.ok( /(invalid|error|exception)/i.test( detailedMsg ), "Detailed parsererror message provided" );
1507 }
1508 };
1509 } );
1510
1511 ajaxTest( "jQuery.ajax() - JSON by content-type", 10, function( assert ) {
1512 return [
1513 {
1514 url: baseURL + "mock.php?action=json",
1515 data: {
1516 "header": "json",
1517 "array": "1"
1518 },
1519 success: function( json ) {
1520 assert.ok( json.length >= 2, "Check length" );
1521 assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
1522 assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
1523 assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
1524 assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
1525 }
1526 },
1527 {
1528 url: baseURL + "mock.php?action=json",
1529 data: [
1530 {
1531 name: "header",
1532 value: "json"
1533 },
1534 {
1535 name: "array",
1536 value: "1"
1537 }
1538 ],
1539 success: function( json ) {
1540 assert.ok( json.length >= 2, "Check length" );
1541 assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
1542 assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
1543 assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
1544 assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
1545 }
1546 }
1547 ];
1548 } );
1549
1550 ajaxTest( "jQuery.ajax() - JSON by content-type disabled with options", 12, function( assert ) {
1551 return [
1552 {
1553 url: url( "mock.php?action=json" ),
1554 data: {
1555 "header": "json",
1556 "array": "1"
1557 },
1558 contents: {
1559 "json": false
1560 },
1561 success: function( text ) {
1562 assert.strictEqual( typeof text, "string", "json wasn't auto-determined" );
1563 var json = JSON.parse( text );
1564 assert.ok( json.length >= 2, "Check length" );
1565 assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
1566 assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
1567 assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
1568 assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
1569 }
1570 },
1571 {
1572 url: url( "mock.php?action=json" ),
1573 data: [
1574 {
1575 name: "header",
1576 value: "json"
1577 },
1578 {
1579 name: "array",
1580 value: "1"
1581 }
1582 ],
1583 contents: {
1584 "json": false
1585 },
1586 success: function( text ) {
1587 assert.strictEqual( typeof text, "string", "json wasn't auto-determined" );
1588 var json = JSON.parse( text );
1589 assert.ok( json.length >= 2, "Check length" );
1590 assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
1591 assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
1592 assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
1593 assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
1594 }
1595 }
1596 ];
1597 } );
1598
1599 ajaxTest( "jQuery.ajax() - simple get", 1, function( assert ) {
1600 return {
1601 type: "GET",
1602 url: url( "mock.php?action=name&name=foo" ),
1603 success: function( msg ) {
1604 assert.strictEqual( msg, "bar", "Check for GET" );
1605 }
1606 };
1607 } );
1608
1609 ajaxTest( "jQuery.ajax() - simple post", 1, function( assert ) {
1610 return {
1611 type: "POST",
1612 url: url( "mock.php?action=name" ),
1613 data: "name=peter",
1614 success: function( msg ) {
1615 assert.strictEqual( msg, "pan", "Check for POST" );
1616 }
1617 };
1618 } );
1619
1620 ajaxTest( "jQuery.ajax() - data option - empty bodies for non-GET requests", 1, function( assert ) {
1621 return {
1622 url: baseURL + "mock.php?action=echoData",
1623 data: undefined,
1624 type: "post",
1625 success: function( result ) {
1626 assert.strictEqual( result, "" );
1627 }
1628 };
1629 } );
1630
1631 ajaxTest( "jQuery.ajax() - data - x-www-form-urlencoded (gh-2658)", 1, function( assert ) {
1632 return {
1633 url: "bogus.html",
1634 data: { devo: "A Beautiful World" },
1635 type: "post",
1636 beforeSend: function( _, s ) {
1637 assert.strictEqual( s.data, "devo=A+Beautiful+World", "data is '+'-encoded" );
1638 return false;
1639 },
1640 error: true
1641 };
1642 } );
1643
1644 ajaxTest( "jQuery.ajax() - data - text/plain (gh-2658)", 2, function( assert ) {
1645 return [
1646 {
1647 url: "bogus.html",
1648 data: { devo: "A Beautiful World" },
1649 type: "post",
1650 contentType: "text/plain",
1651 beforeSend: function( _, s ) {
1652 assert.strictEqual( s.data, "devo=A%20Beautiful%20World", "data is %20-encoded" );
1653 return false;
1654 },
1655 error: true
1656 },
1657 {
1658 url: "bogus.html",
1659 data: [
1660 {
1661 name: "devo",
1662 value: "A Beautiful World"
1663 }
1664 ],
1665 type: "post",
1666 contentType: "text/plain",
1667 beforeSend: function( _, s ) {
1668 assert.strictEqual( s.data, "devo=A%20Beautiful%20World", "data is %20-encoded" );
1669 return false;
1670 },
1671 error: true
1672 }
1673 ];
1674 } );
1675
1676 ajaxTest( "jQuery.ajax() - don't escape %20 with contentType override (gh-4119)", 1, function( assert ) {
1677 return {
1678 url: "bogus.html",
1679 contentType: "application/x-www-form-urlencoded",
1680 headers: { "content-type": "application/json" },
1681 method: "post",
1682 dataType: "json",
1683 data: "{\"val\":\"%20\"}",
1684 beforeSend: function( _, s ) {
1685 assert.strictEqual( s.data, "{\"val\":\"%20\"}", "data is not %20-encoded" );
1686 return false;
1687 },
1688 error: true
1689 };
1690 } );
1691
1692 ajaxTest( "jQuery.ajax() - escape %20 with contentType override (gh-4119)", 1, function( assert ) {
1693 return {
1694 url: "bogus.html",
1695 contentType: "application/json",
1696 headers: { "content-type": "application/x-www-form-urlencoded" },
1697 method: "post",
1698 dataType: "json",
1699 data: "{\"val\":\"%20\"}",
1700 beforeSend: function( _, s ) {
1701 assert.strictEqual( s.data, "{\"val\":\"+\"}", "data is %20-encoded" );
1702 return false;
1703 },
1704 error: true
1705 };
1706 } );
1707
1708 ajaxTest( "jQuery.ajax() - override contentType with header (gh-4119)", 1, function( assert ) {
1709 return {
1710 url: "bogus.html",
1711 contentType: "application/json",
1712 headers: { "content-type": "application/x-www-form-urlencoded" },
1713 beforeSend: function( _, s ) {
1714 assert.strictEqual( s.contentType, "application/x-www-form-urlencoded",
1715 "contentType is overwritten" );
1716 return false;
1717 },
1718 error: true
1719 };
1720 } );
1721
1722 ajaxTest( "jQuery.ajax() - data - no processing POST", 2, function( assert ) {
1723 return [
1724 {
1725 url: "bogus.html",
1726 data: { devo: "A Beautiful World" },
1727 type: "post",
1728 contentType: "x-special-sauce",
1729 processData: false,
1730 beforeSend: function( _, s ) {
1731 assert.deepEqual( s.data, { devo: "A Beautiful World" }, "data is not processed" );
1732 return false;
1733 },
1734 error: true
1735 },
1736 {
1737 url: "bogus.html",
1738 data: [
1739 {
1740 name: "devo",
1741 value: "A Beautiful World"
1742 }
1743 ],
1744 type: "post",
1745 contentType: "x-special-sauce",
1746 processData: false,
1747 beforeSend: function( _, s ) {
1748 assert.deepEqual( s.data, [
1749 {
1750 name: "devo",
1751 value: "A Beautiful World"
1752 }
1753 ], "data is not processed" );
1754 return false;
1755 },
1756 error: true
1757 }
1758 ];
1759 } );
1760
1761 ajaxTest( "jQuery.ajax() - data - no processing GET", 2, function( assert ) {
1762 return [
1763 {
1764 url: "bogus.html",
1765 data: { devo: "A Beautiful World" },
1766 type: "get",
1767 contentType: "x-something-else",
1768 processData: false,
1769 beforeSend: function( _, s ) {
1770 assert.deepEqual( s.data, { devo: "A Beautiful World" }, "data is not processed" );
1771 return false;
1772 },
1773 error: true
1774 },
1775 {
1776 url: "bogus.html",
1777 data: [
1778 {
1779 name: "devo",
1780 value: "A Beautiful World"
1781 }
1782 ],
1783 type: "get",
1784 contentType: "x-something-else",
1785 processData: false,
1786 beforeSend: function( _, s ) {
1787 assert.deepEqual( s.data, [
1788 {
1789 name: "devo",
1790 value: "A Beautiful World"
1791 }
1792 ], "data is not processed" );
1793 return false;
1794 },
1795 error: true
1796 }
1797 ];
1798 } );
1799
1800 ajaxTest( "jQuery.ajax() - data - process string with GET", 2, function( assert ) {
1801 return {
1802 url: "bogus.html",
1803 data: "a=1&b=2",
1804 type: "get",
1805 contentType: "x-something-else",
1806 processData: false,
1807 beforeSend: function( _, s ) {
1808 assert.equal( s.url, "bogus.html?a=1&b=2", "added data to url" );
1809 assert.equal( s.data, undefined, "removed data from settings" );
1810 return false;
1811 },
1812 error: true
1813 };
1814 } );
1815
1816 var ifModifiedNow = new Date();
1817
1818 jQuery.each(
1819 /* jQuery.each arguments start */
1820 {
1821 " (cache)": true,
1822 " (no cache)": false
1823 },
1824 function( label, cache ) {
1825 jQuery.each(
1826 {
1827 "If-Modified-Since": {
1828 url: "mock.php?action=ims",
1829 qunitMethod: "test"
1830 },
1831 "Etag": {
1832 url: "mock.php?action=etag",
1833
1834 // Support: TestSwarm
1835 // TestSwarm is now proxied via Cloudflare which cuts out
1836 // headers relevant for ETag tests, failing them. We're still
1837 // running those tests in Karma on Chrome & Firefox (including
1838 // Firefox ESR).
1839 qunitMethod: QUnit.isSwarm ? "skip" : "test"
1840 }
1841 },
1842 function( type, data ) {
1843 var url = baseURL + data.url + "&ts=" + ifModifiedNow++;
1844 QUnit[ data.qunitMethod ]( "jQuery.ajax() - " + type +
1845 " support" + label, function( assert ) {
1846 assert.expect( 4 );
1847 var done = assert.async();
1848 jQuery.ajax( {
1849 url: url,
1850 ifModified: true,
1851 cache: cache,
1852 success: function( _, status ) {
1853 assert.strictEqual( status, "success", "Initial status is 'success'" );
1854 jQuery.ajax( {
1855 url: url,
1856 ifModified: true,
1857 cache: cache,
1858 success: function( data, status, jqXHR ) {
1859 assert.strictEqual( status, "notmodified", "Following status is 'notmodified'" );
1860 assert.strictEqual( jqXHR.status, 304, "XHR status is 304" );
1861 assert.equal( data, null, "no response body is given" );
1862 },
1863 complete: function() {
1864 done();
1865 }
1866 } );
1867 }
1868 } );
1869 } );
1870 }
1871 );
1872 }
1873 /* jQuery.each arguments end */
1874 );
1875
1876 ajaxTest( "jQuery.ajax() - failing cross-domain (non-existing)", 1, function( assert ) {
1877 return {
1878
1879 // see RFC 2606
1880 url: "https://example.invalid",
1881 error: function( xhr, _, e ) {
1882 assert.ok( true, "file not found: " + xhr.status + " => " + e );
1883 }
1884 };
1885 } );
1886
1887 ajaxTest( "jQuery.ajax() - failing cross-domain", 1, function( assert ) {
1888 return {
1889 url: "https://" + externalHost,
1890 error: function( xhr, _, e ) {
1891 assert.ok( true, "access denied: " + xhr.status + " => " + e );
1892 }
1893 };
1894 } );
1895
1896 ajaxTest( "jQuery.ajax() - atom+xml", 1, function( assert ) {
1897 return {
1898 url: url( "mock.php?action=atom" ),
1899 success: function() {
1900 assert.ok( true, "success" );
1901 }
1902 };
1903 } );
1904
1905 QUnit.test( "jQuery.ajax() - statusText", function( assert ) {
1906 assert.expect( 3 );
1907 var done = assert.async();
1908 jQuery.ajax( url( "mock.php?action=status&code=200&text=Hello" ) ).done( function( _, statusText, jqXHR ) {
1909 assert.strictEqual( statusText, "success", "callback status text ok for success" );
1910 assert.ok( [ "Hello", "OK", "success" ].indexOf( jqXHR.statusText ) > -1,
1911 "jqXHR status text ok for success (" + jqXHR.statusText + ")" );
1912 jQuery.ajax( url( "mock.php?action=status&code=404&text=World" ) ).fail( function( jqXHR, statusText ) {
1913 assert.strictEqual( statusText, "error", "callback status text ok for error" );
1914 done();
1915 } );
1916 } );
1917 } );
1918
1919 QUnit.test( "jQuery.ajax() - statusCode", function( assert ) {
1920 assert.expect( 20 );
1921 var done = assert.async(),
1922 count = 12;
1923
1924 function countComplete() {
1925 if ( !--count ) {
1926 done();
1927 }
1928 }
1929
1930 function createStatusCodes( name, isSuccess ) {
1931 name = "Test " + name + " " + ( isSuccess ? "success" : "error" );
1932 return {
1933 200: function() {
1934 assert.ok( isSuccess, name );
1935 },
1936 404: function() {
1937 assert.ok( !isSuccess, name );
1938 }
1939 };
1940 }
1941
1942 jQuery.each(
1943 /* jQuery.each arguments start */
1944 {
1945 "name.html": true,
1946 "404.txt": false
1947 },
1948 function( uri, isSuccess ) {
1949 jQuery.ajax( url( uri ), {
1950 statusCode: createStatusCodes( "in options", isSuccess ),
1951 complete: countComplete
1952 } );
1953
1954 jQuery.ajax( url( uri ), {
1955 complete: countComplete
1956 } ).statusCode( createStatusCodes( "immediately with method", isSuccess ) );
1957
1958 jQuery.ajax( url( uri ), {
1959 complete: function( jqXHR ) {
1960 jqXHR.statusCode( createStatusCodes( "on complete", isSuccess ) );
1961 countComplete();
1962 }
1963 } );
1964
1965 jQuery.ajax( url( uri ), {
1966 complete: function( jqXHR ) {
1967 setTimeout( function() {
1968 jqXHR.statusCode( createStatusCodes( "very late binding", isSuccess ) );
1969 countComplete();
1970 }, 100 );
1971 }
1972 } );
1973
1974 jQuery.ajax( url( uri ), {
1975 statusCode: createStatusCodes( "all (options)", isSuccess ),
1976 complete: function( jqXHR ) {
1977 jqXHR.statusCode( createStatusCodes( "all (on complete)", isSuccess ) );
1978 setTimeout( function() {
1979 jqXHR.statusCode( createStatusCodes( "all (very late binding)", isSuccess ) );
1980 countComplete();
1981 }, 100 );
1982 }
1983 } ).statusCode( createStatusCodes( "all (immediately with method)", isSuccess ) );
1984
1985 var testString = "";
1986
1987 jQuery.ajax( url( uri ), {
1988 success: function( a, b, jqXHR ) {
1989 assert.ok( isSuccess, "success" );
1990 var statusCode = {};
1991 statusCode[ jqXHR.status ] = function() {
1992 testString += "B";
1993 };
1994 jqXHR.statusCode( statusCode );
1995 testString += "A";
1996 },
1997 error: function( jqXHR ) {
1998 assert.ok( !isSuccess, "error" );
1999 var statusCode = {};
2000 statusCode[ jqXHR.status ] = function() {
2001 testString += "B";
2002 };
2003 jqXHR.statusCode( statusCode );
2004 testString += "A";
2005 },
2006 complete: function() {
2007 assert.strictEqual(
2008 testString,
2009 "AB",
2010 "Test statusCode callbacks are ordered like " + ( isSuccess ? "success" : "error" ) + " callbacks"
2011 );
2012 countComplete();
2013 }
2014 } );
2015
2016 }
2017 /* jQuery.each arguments end*/
2018 );
2019 } );
2020
2021 ajaxTest( "jQuery.ajax() - transitive conversions", 8, function( assert ) {
2022 return [
2023 {
2024 url: url( "mock.php?action=json" ),
2025 converters: {
2026 "json myJson": function( data ) {
2027 assert.ok( true, "converter called" );
2028 return data;
2029 }
2030 },
2031 dataType: "myJson",
2032 success: function() {
2033 assert.ok( true, "Transitive conversion worked" );
2034 assert.strictEqual( this.dataTypes[ 0 ], "text", "response was retrieved as text" );
2035 assert.strictEqual( this.dataTypes[ 1 ], "myjson", "request expected myjson dataType" );
2036 }
2037 },
2038 {
2039 url: url( "mock.php?action=json" ),
2040 converters: {
2041 "json myJson": function( data ) {
2042 assert.ok( true, "converter called (*)" );
2043 return data;
2044 }
2045 },
2046 contents: false, /* headers are wrong so we ignore them */
2047 dataType: "* myJson",
2048 success: function() {
2049 assert.ok( true, "Transitive conversion worked (*)" );
2050 assert.strictEqual( this.dataTypes[ 0 ], "text", "response was retrieved as text (*)" );
2051 assert.strictEqual( this.dataTypes[ 1 ], "myjson", "request expected myjson dataType (*)" );
2052 }
2053 }
2054 ];
2055 } );
2056
2057 ajaxTest( "jQuery.ajax() - overrideMimeType", 2, function( assert ) {
2058 return [
2059 {
2060 url: url( "mock.php?action=json" ),
2061 beforeSend: function( xhr ) {
2062 xhr.overrideMimeType( "application/json" );
2063 },
2064 success: function( json ) {
2065 assert.ok( json.data, "Mimetype overridden using beforeSend" );
2066 }
2067 },
2068 {
2069 url: url( "mock.php?action=json" ),
2070 mimeType: "application/json",
2071 success: function( json ) {
2072 assert.ok( json.data, "Mimetype overridden using mimeType option" );
2073 }
2074 }
2075 ];
2076 } );
2077
2078 ajaxTest( "jQuery.ajax() - empty json gets to error callback instead of success callback.", 1, function( assert ) {
2079 return {
2080 url: url( "mock.php?action=echoData" ),
2081 error: function( _, __, error ) {
2082 assert.equal( typeof error === "object", true, "Didn't get back error object for empty json response" );
2083 },
2084 dataType: "json"
2085 };
2086 } );
2087
2088 ajaxTest( "trac-2688 - jQuery.ajax() - beforeSend, cancel request", 2, function( assert ) {
2089 return {
2090 create: function() {
2091 return jQuery.ajax( {
2092 url: url( "name.html" ),
2093 beforeSend: function() {
2094 assert.ok( true, "beforeSend got called, canceling" );
2095 return false;
2096 },
2097 success: function() {
2098 assert.ok( false, "request didn't get canceled" );
2099 },
2100 complete: function() {
2101 assert.ok( false, "request didn't get canceled" );
2102 },
2103 error: function() {
2104 assert.ok( false, "request didn't get canceled" );
2105 }
2106 } );
2107 },
2108 fail: function( _, reason ) {
2109 assert.strictEqual( reason, "canceled", "canceled request must fail with 'canceled' status text" );
2110 }
2111 };
2112 } );
2113
2114 ajaxTest( "trac-2806 - jQuery.ajax() - data option - evaluate function values", 1, function( assert ) {
2115 return {
2116 url: baseURL + "mock.php?action=echoQuery",
2117 data: {
2118 key: function() {
2119 return "value";
2120 }
2121 },
2122 success: function( result ) {
2123 assert.strictEqual( result, "action=echoQuery&key=value" );
2124 }
2125 };
2126 } );
2127
2128 QUnit.test( "trac-7531 - jQuery.ajax() - Location object as url", function( assert ) {
2129 assert.expect( 1 );
2130
2131 var xhr,
2132 success = false;
2133 try {
2134 xhr = jQuery.ajax( {
2135 url: window.location
2136 } );
2137 success = true;
2138 xhr.abort();
2139 } catch ( e ) {
2140
2141 }
2142 assert.ok( success, "document.location did not generate exception" );
2143 } );
2144
2145 jQuery.each( [ " - Same Domain", " - Cross Domain" ], function( crossDomain, label ) {
2146 ajaxTest( "trac-7578 - jQuery.ajax() - JSONP - default for cache option" + label, 1, function( assert ) {
2147 return {
2148 url: baseURL + "mock.php?action=jsonp",
2149 dataType: "jsonp",
2150 crossDomain: crossDomain,
2151 beforeSend: function() {
2152 assert.strictEqual( this.cache, false, "cache must be false on JSON request" );
2153 return false;
2154 },
2155 error: true
2156 };
2157 } );
2158 } );
2159
2160 ajaxTest( "trac-8107 - jQuery.ajax() - multiple method signatures introduced in 1.5", 4, function( assert ) {
2161 return [
2162 {
2163 create: function() {
2164 return jQuery.ajax();
2165 },
2166 done: function() {
2167 assert.ok( true, "With no arguments" );
2168 }
2169 },
2170 {
2171 create: function() {
2172 return jQuery.ajax( baseURL + "name.html" );
2173 },
2174 done: function() {
2175 assert.ok( true, "With only string URL argument" );
2176 }
2177 },
2178 {
2179 create: function() {
2180 return jQuery.ajax( baseURL + "name.html", {} );
2181 },
2182 done: function() {
2183 assert.ok( true, "With string URL param and map" );
2184 }
2185 },
2186 {
2187 create: function( options ) {
2188 return jQuery.ajax( options );
2189 },
2190 url: baseURL + "name.html",
2191 success: function() {
2192 assert.ok( true, "With only map" );
2193 }
2194 }
2195 ];
2196 } );
2197
2198 jQuery.each( [ " - Same Domain", " - Cross Domain" ], function( crossDomain, label ) {
2199 ajaxTest( "trac-8205 - jQuery.ajax() - JSONP - re-use callbacks name" + label, 4, function( assert ) {
2200 return {
2201 url: baseURL + "mock.php?action=jsonp",
2202 dataType: "jsonp",
2203 crossDomain: crossDomain,
2204 beforeSend: function( jqXHR, s ) {
2205 s.callback = s.jsonpCallback;
2206
2207 assert.ok( this.callback in window, "JSONP callback name is in the window" );
2208 },
2209 success: function() {
2210 var previous = this;
2211
2212 assert.strictEqual(
2213 previous.jsonpCallback,
2214 undefined,
2215 "jsonpCallback option is set back to default in callbacks"
2216 );
2217
2218 assert.ok(
2219 !( this.callback in window ),
2220 "JSONP callback name was removed from the window"
2221 );
2222
2223 jQuery.ajax( {
2224 url: baseURL + "mock.php?action=jsonp",
2225 dataType: "jsonp",
2226 crossDomain: crossDomain,
2227 beforeSend: function() {
2228 assert.strictEqual( this.jsonpCallback, previous.callback, "JSONP callback name is re-used" );
2229 return false;
2230 }
2231 } );
2232 }
2233 };
2234 } );
2235 } );
2236
2237 QUnit.test( "trac-9887 - jQuery.ajax() - Context with circular references (trac-9887)", function( assert ) {
2238 assert.expect( 2 );
2239
2240 var success = false,
2241 context = {};
2242 context.field = context;
2243 try {
2244 jQuery.ajax( "non-existing", {
2245 context: context,
2246 beforeSend: function() {
2247 assert.ok( this === context, "context was not deep extended" );
2248 return false;
2249 }
2250 } );
2251 success = true;
2252 } catch ( e ) {
2253 console.log( e );
2254 }
2255 assert.ok( success, "context with circular reference did not generate an exception" );
2256 } );
2257
2258 jQuery.each( [ "as argument", "in settings object" ], function( inSetting, title ) {
2259
2260 function request( assert, url, test ) {
2261 return {
2262 create: function() {
2263 return jQuery.ajax( inSetting ? { url: url } : url );
2264 },
2265 done: function() {
2266 assert.ok( true, ( test || url ) + " " + title );
2267 }
2268 };
2269 }
2270
2271 ajaxTest( "trac-10093 - jQuery.ajax() - falsy url " + title, 4, function( assert ) {
2272 return [
2273 request( assert, "", "empty string" ),
2274 request( assert, false ),
2275 request( assert, null ),
2276 request( assert, undefined )
2277 ];
2278 } );
2279 } );
2280
2281 ajaxTest( "trac-11151 - jQuery.ajax() - parse error body", 2, function( assert ) {
2282 return {
2283 url: url( "mock.php?action=error&json=1" ),
2284 dataFilter: function( string ) {
2285 assert.ok( false, "dataFilter called" );
2286 return string;
2287 },
2288 error: function( jqXHR ) {
2289 assert.strictEqual( jqXHR.responseText, "{ \"code\": 40, \"message\": \"Bad Request\" }", "Error body properly set" );
2290 assert.deepEqual( jqXHR.responseJSON, { code: 40, message: "Bad Request" }, "Error body properly parsed" );
2291 }
2292 };
2293 } );
2294
2295 ajaxTest( "trac-11426 - jQuery.ajax() - loading binary data shouldn't throw an exception in IE", 1, function( assert ) {
2296 return {
2297 url: url( "1x1.jpg" ),
2298 success: function( data ) {
2299 assert.ok( data === undefined || /JFIF/.test( data ), "success callback reached" );
2300 }
2301 };
2302 } );
2303
2304 if ( typeof window.ArrayBuffer === "undefined" || typeof new XMLHttpRequest().responseType !== "string" ) {
2305
2306 QUnit.skip( "No ArrayBuffer support in XHR", jQuery.noop );
2307 } else {
2308
2309 // No built-in support for binary data, but it's easy to add via a prefilter
2310 jQuery.ajaxPrefilter( "arraybuffer", function( s ) {
2311 s.xhrFields = { responseType: "arraybuffer" };
2312 s.responseFields.arraybuffer = "response";
2313 s.converters[ "binary arraybuffer" ] = true;
2314 } );
2315
2316 ajaxTest( "gh-2498 - jQuery.ajax() - binary data shouldn't throw an exception", 2, function( assert ) {
2317 return {
2318 url: url( "1x1.jpg" ),
2319 dataType: "arraybuffer",
2320 success: function( data, s, jqxhr ) {
2321 assert.ok( data instanceof window.ArrayBuffer, "correct data type" );
2322 assert.ok( jqxhr.response instanceof window.ArrayBuffer, "data in jQXHR" );
2323 }
2324 };
2325 } );
2326 }
2327
2328 QUnit.test( "trac-11743 - jQuery.ajax() - script, throws exception", function( assert ) {
2329 assert.expect( 1 );
2330 var done = assert.async();
2331 var onerror = window.onerror;
2332 window.onerror = function() {
2333 assert.ok( true, "Exception thrown" );
2334 window.onerror = onerror;
2335 done();
2336 };
2337 jQuery.ajax( {
2338 url: baseURL + "badjson.js",
2339 dataType: "script",
2340 throws: true
2341 } );
2342 } );
2343
2344 jQuery.each( [ "method", "type" ], function( _, globalOption ) {
2345 function request( assert, option ) {
2346 var options = {
2347 url: url( "mock.php?action=echoData" ),
2348 data: "hello",
2349 success: function( msg ) {
2350 assert.strictEqual( msg, "hello", "Check for POST (no override)" );
2351 }
2352 };
2353 if ( option ) {
2354 options[ option ] = "GET";
2355 options.success = function( msg ) {
2356 assert.strictEqual( msg, "", "Check for no POST (overriding with " + option + ")" );
2357 };
2358 }
2359 return options;
2360 }
2361
2362 ajaxTest(
2363 "trac-12004 - jQuery.ajax() - method is an alias of type - " +
2364 globalOption + " set globally", 3,
2365 function( assert ) {
2366 return {
2367 setup: function() {
2368 var options = {};
2369 options[ globalOption ] = "POST";
2370 jQuery.ajaxSetup( options );
2371 },
2372 requests: [
2373 request( assert, "type" ),
2374 request( assert, "method" ),
2375 request( assert )
2376 ]
2377 };
2378 }
2379 );
2380 } );
2381
2382 ajaxTest( "trac-13276 - jQuery.ajax() - compatibility between XML documents from ajax requests and parsed string", 1, function( assert ) {
2383 return {
2384 url: baseURL + "dashboard.xml",
2385 dataType: "xml",
2386 success: function( ajaxXML ) {
2387 var parsedXML = jQuery( jQuery.parseXML( "<tab title=\"Added\">blibli</tab>" ) ).find( "tab" );
2388 ajaxXML = jQuery( ajaxXML );
2389 try {
2390 ajaxXML.find( "infowindowtab" ).append( parsedXML );
2391 } catch ( e ) {
2392 assert.strictEqual( e, undefined, "error" );
2393 return;
2394 }
2395 assert.strictEqual( ajaxXML.find( "tab" ).length, 3, "Parsed node was added properly" );
2396 }
2397 };
2398 } );
2399
2400 ajaxTest( "trac-13292 - jQuery.ajax() - converter is bypassed for 204 requests", 3, function( assert ) {
2401 return {
2402 url: baseURL + "mock.php?action=status&code=204&text=No+Content",
2403 dataType: "testing",
2404 converters: {
2405 "* testing": function() {
2406 throw "converter was called";
2407 }
2408 },
2409 success: function( data, status, jqXHR ) {
2410 assert.strictEqual( jqXHR.status, 204, "status code is 204" );
2411 assert.strictEqual( status, "nocontent", "status text is 'nocontent'" );
2412 assert.strictEqual( data, undefined, "data is undefined" );
2413 },
2414 error: function( _, status, error ) {
2415 assert.ok( false, "error" );
2416 assert.strictEqual( status, "parsererror", "Parser Error" );
2417 assert.strictEqual( error, "converter was called", "Converter was called" );
2418 }
2419 };
2420 } );
2421
2422 ajaxTest( "trac-13388 - jQuery.ajax() - responseXML", 3, function( assert ) {
2423 return {
2424 url: url( "with_fries.xml" ),
2425 dataType: "xml",
2426 success: function( resp, _, jqXHR ) {
2427 assert.notStrictEqual( resp, undefined, "XML document exists" );
2428 assert.ok( "responseXML" in jqXHR, "jqXHR.responseXML exists" );
2429 assert.strictEqual( resp, jqXHR.responseXML, "jqXHR.responseXML is set correctly" );
2430 }
2431 };
2432 } );
2433
2434 ajaxTest( "trac-13922 - jQuery.ajax() - converter is bypassed for HEAD requests", 3, function( assert ) {
2435 return {
2436 url: baseURL + "mock.php?action=json",
2437 method: "HEAD",
2438 data: {
2439 header: "yes"
2440 },
2441 converters: {
2442 "text json": function() {
2443 throw "converter was called";
2444 }
2445 },
2446 success: function( data, status ) {
2447 assert.ok( true, "success" );
2448 assert.strictEqual( status, "nocontent", "data is undefined" );
2449 assert.strictEqual( data, undefined, "data is undefined" );
2450 },
2451 error: function( _, status, error ) {
2452 assert.ok( false, "error" );
2453 assert.strictEqual( status, "parsererror", "Parser Error" );
2454 assert.strictEqual( error, "converter was called", "Converter was called" );
2455 }
2456 };
2457 } );
2458
2459 // Chrome 78 dropped support for synchronous XHR requests inside of
2460 // beforeunload, unload, pagehide, and visibilitychange event handlers.
2461 // See https://bugs.chromium.org/p/chromium/issues/detail?id=952452
2462 // Safari 13 did similar changes. The below check will catch them both.
2463 if ( !/webkit/i.test( navigator.userAgent ) ) {
2464 testIframe(
2465 "trac-14379 - jQuery.ajax() on unload",
2466 "ajax/onunload.html",
2467 function( assert, jQuery, window, document, status ) {
2468 assert.expect( 1 );
2469 assert.strictEqual( status, "success", "Request completed" );
2470 }
2471 );
2472 }
2473
2474 ajaxTest( "trac-14683 - jQuery.ajax() - Exceptions thrown synchronously by xhr.send should be caught", 4, function( assert ) {
2475 return [ {
2476 url: baseURL + "mock.php?action=echoData",
2477 method: "POST",
2478 data: {
2479 toString: function() {
2480 throw "Can't parse";
2481 }
2482 },
2483 processData: false,
2484 done: function( data ) {
2485 assert.ok( false, "done: " + data );
2486 },
2487 fail: function( jqXHR, status, error ) {
2488 assert.ok( true, "exception caught: " + error );
2489 assert.strictEqual( jqXHR.status, 0, "proper status code" );
2490 assert.strictEqual( status, "error", "proper status" );
2491 }
2492 }, {
2493 url: "https://" + externalHost + ":80q",
2494 done: function( data ) {
2495 assert.ok( false, "done: " + data );
2496 },
2497 fail: function( _, status, error ) {
2498 assert.ok( true, "fail: " + status + " - " + error );
2499 }
2500 } ];
2501 } );
2502
2503 ajaxTest( "gh-2587 - when content-type not xml, but looks like one", 1, function( assert ) {
2504 return {
2505 url: url( "mock.php?action=contentType" ),
2506 data: {
2507 contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
2508 "response": "<test/>"
2509 },
2510 success: function( result ) {
2511 assert.strictEqual(
2512 typeof result,
2513 "string",
2514 "Should handle it as a string, not xml"
2515 );
2516 }
2517 };
2518 } );
2519
2520 ajaxTest( "gh-2587 - when content-type not xml, but looks like one", 1, function( assert ) {
2521 return {
2522 url: url( "mock.php?action=contentType" ),
2523 data: {
2524 contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
2525 "response": "<test/>"
2526 },
2527 success: function( result ) {
2528 assert.strictEqual(
2529 typeof result,
2530 "string",
2531 "Should handle it as a string, not xml"
2532 );
2533 }
2534 };
2535 } );
2536
2537 ajaxTest( "gh-2587 - when content-type not json, but looks like one", 1, function( assert ) {
2538 return {
2539 url: url( "mock.php?action=contentType" ),
2540 data: {
2541 contentType: "test/jsontest",
2542 "response": JSON.stringify( { test: "test" } )
2543 },
2544 success: function( result ) {
2545 assert.strictEqual(
2546 typeof result,
2547 "string",
2548 "Should handle it as a string, not json"
2549 );
2550 }
2551 };
2552 } );
2553
2554 ajaxTest( "gh-2587 - when content-type not html, but looks like one", 1, function( assert ) {
2555 return {
2556 url: url( "mock.php?action=contentType" ),
2557 data: {
2558 contentType: "test/htmltest",
2559 "response": "<p>test</p>"
2560 },
2561 success: function( result ) {
2562 assert.strictEqual(
2563 typeof result,
2564 "string",
2565 "Should handle it as a string, not html"
2566 );
2567 }
2568 };
2569 } );
2570
2571 ajaxTest( "gh-2587 - when content-type not javascript, but looks like one", 1, function( assert ) {
2572 return {
2573 url: url( "mock.php?action=contentType" ),
2574 data: {
2575 contentType: "test/testjavascript",
2576 "response": "alert(1)"
2577 },
2578 success: function( result ) {
2579 assert.strictEqual(
2580 typeof result,
2581 "string",
2582 "Should handle it as a string, not javascript"
2583 );
2584 }
2585 };
2586 } );
2587
2588 ajaxTest( "gh-2587 - when content-type not ecmascript, but looks like one", 1, function( assert ) {
2589 return {
2590 url: url( "mock.php?action=contentType" ),
2591 data: {
2592 contentType: "test/testjavascript",
2593 "response": "alert(1)"
2594 },
2595 success: function( result ) {
2596 assert.strictEqual(
2597 typeof result,
2598 "string",
2599 "Should handle it as a string, not ecmascript"
2600 );
2601 }
2602 };
2603 } );
2604
2605 //----------- jQuery.ajaxPrefilter()
2606
2607 ajaxTest( "jQuery.ajaxPrefilter() - abort", 1, function( assert ) {
2608 return {
2609 dataType: "prefix",
2610 setup: function() {
2611
2612 // Ensure prefix does not throw an error
2613 jQuery.ajaxPrefilter( "+prefix", function( options, _, jqXHR ) {
2614 if ( options.abortInPrefilter ) {
2615 jqXHR.abort();
2616 }
2617 } );
2618 },
2619 abortInPrefilter: true,
2620 error: function() {
2621 assert.ok( false, "error callback called" );
2622 },
2623 fail: function( _, reason ) {
2624 assert.strictEqual( reason, "canceled", "Request aborted by the prefilter must fail with 'canceled' status text" );
2625 }
2626 };
2627 } );
2628
2629 //----------- jQuery.ajaxSetup()
2630
2631 QUnit.test( "jQuery.ajaxSetup()", function( assert ) {
2632 assert.expect( 1 );
2633 var done = assert.async();
2634 jQuery.ajaxSetup( {
2635 url: url( "mock.php?action=name&name=foo" ),
2636 success: function( msg ) {
2637 assert.strictEqual( msg, "bar", "Check for GET" );
2638 done();
2639 }
2640 } );
2641 jQuery.ajax();
2642 } );
2643
2644 QUnit.test( "jQuery.ajaxSetup({ timeout: Number }) - with global timeout", function( assert ) {
2645 assert.expect( 2 );
2646 var done = assert.async();
2647 var passed = 0,
2648 pass = function() {
2649 assert.ok( passed++ < 2, "Error callback executed" );
2650 if ( passed === 2 ) {
2651 jQuery( document ).off( "ajaxError.setupTest" );
2652 done();
2653 }
2654 },
2655 fail = function( a, b ) {
2656 assert.ok( false, "Check for timeout failed " + a + " " + b );
2657 done();
2658 };
2659
2660 jQuery( document ).on( "ajaxError.setupTest", pass );
2661
2662 jQuery.ajaxSetup( {
2663 timeout: 1000
2664 } );
2665
2666 jQuery.ajax( {
2667 type: "GET",
2668 url: url( "mock.php?action=wait&wait=5" ),
2669 error: pass,
2670 success: fail
2671 } );
2672 } );
2673
2674 QUnit.test( "jQuery.ajaxSetup({ timeout: Number }) with localtimeout", function( assert ) {
2675 assert.expect( 1 );
2676 var done = assert.async();
2677 jQuery.ajaxSetup( {
2678 timeout: 50
2679 } );
2680 jQuery.ajax( {
2681 type: "GET",
2682 timeout: 15000,
2683 url: url( "mock.php?action=wait&wait=1" ),
2684 error: function() {
2685 assert.ok( false, "Check for local timeout failed" );
2686 done();
2687 },
2688 success: function() {
2689 assert.ok( true, "Check for local timeout" );
2690 done();
2691 }
2692 } );
2693 } );
2694
2695 //----------- domManip()
2696
2697 QUnit.test( "trac-11264 - domManip() - no side effect because of ajaxSetup or global events", function( assert ) {
2698 assert.expect( 1 );
2699
2700 jQuery.ajaxSetup( {
2701 type: "POST"
2702 } );
2703
2704 jQuery( document ).on( "ajaxStart ajaxStop", function() {
2705 assert.ok( false, "Global event triggered" );
2706 } );
2707
2708 jQuery( "#qunit-fixture" ).append( "<script src='" + baseURL + "mock.php?action=script'></script>" );
2709
2710 jQuery( document ).off( "ajaxStart ajaxStop" );
2711 } );
2712
2713 QUnit.test(
2714 "jQuery#load() - always use GET method even if overridden through ajaxSetup (trac-11264)",
2715 function( assert ) {
2716 assert.expect( 1 );
2717 var done = assert.async();
2718
2719 jQuery.ajaxSetup( {
2720 type: "POST"
2721 } );
2722
2723 jQuery( "#qunit-fixture" ).load( baseURL + "mock.php?action=echoMethod", function( method ) {
2724 assert.equal( method, "GET" );
2725 done();
2726 } );
2727 }
2728 );
2729
2730 QUnit.test(
2731 "jQuery#load() - should resolve with correct context",
2732 function( assert ) {
2733 assert.expect( 2 );
2734 var done = assert.async();
2735 var ps = jQuery( "<p></p><p></p>" );
2736 var i = 0;
2737
2738 ps.appendTo( "#qunit-fixture" );
2739
2740 ps.load( baseURL + "mock.php?action=echoMethod", function() {
2741 assert.strictEqual( this, ps[ i++ ] );
2742
2743 if ( i === 2 ) {
2744 done();
2745 }
2746 } );
2747 }
2748 );
2749
2750 QUnit.test(
2751 "trac-11402 - domManip() - script in comments are properly evaluated",
2752 function( assert ) {
2753 assert.expect( 2 );
2754 jQuery( "#qunit-fixture" ).load( baseURL + "cleanScript.html", assert.async() );
2755 }
2756 );
2757
2758 //----------- jQuery.get()
2759
2760 QUnit.test( "jQuery.get( String, Hash, Function ) - parse xml and use text() on nodes", function( assert ) {
2761 assert.expect( 2 );
2762 var done = assert.async();
2763 jQuery.get( url( "dashboard.xml" ), function( xml ) {
2764 var content = [];
2765 jQuery( "tab", xml ).each( function() {
2766 content.push( jQuery( this ).text() );
2767 } );
2768 assert.strictEqual( content[ 0 ], "blabla", "Check first tab" );
2769 assert.strictEqual( content[ 1 ], "blublu", "Check second tab" );
2770 done();
2771 } );
2772 } );
2773
2774 QUnit.test( "trac-8277 - jQuery.get( String, Function ) - data in ajaxSettings", function( assert ) {
2775 assert.expect( 1 );
2776 var done = assert.async();
2777 jQuery.ajaxSetup( {
2778 data: "helloworld"
2779 } );
2780 jQuery.get( url( "mock.php?action=echoQuery" ), function( data ) {
2781 assert.ok( /helloworld$/.test( data ), "Data from ajaxSettings was used" );
2782 done();
2783 } );
2784 } );
2785
2786 QUnit.test( "jQuery.get( String, null-ish, String ) - dataType with null callback (gh-4989)",
2787 function( assert ) {
2788 assert.expect( 2 );
2789 var done = assert.async( 2 );
2790
2791 jQuery.get( url( "mock.php?action=json&header" ), null, "json" )
2792 .then( function( json ) {
2793 assert.deepEqual( json, { data: { lang: "en", length: 25 } },
2794 "`dataType: \"json\"` applied with a `null` callback" );
2795 done();
2796 } );
2797
2798 jQuery.get( url( "mock.php?action=json&header" ), null, "text" )
2799 .then( function( text ) {
2800 assert.strictEqual( text, "{\"data\":{\"lang\":\"en\",\"length\":25}}",
2801 "`dataType: \"text\"` applied with a `null` callback" );
2802 done();
2803 } );
2804 } );
2805
2806 //----------- jQuery.getJSON()
2807
2808 QUnit.test( "jQuery.getJSON( String, Hash, Function ) - JSON array", function( assert ) {
2809 assert.expect( 5 );
2810 var done = assert.async();
2811 jQuery.getJSON(
2812 url( "mock.php?action=json" ),
2813 {
2814 "array": "1"
2815 },
2816 function( json ) {
2817 assert.ok( json.length >= 2, "Check length" );
2818 assert.strictEqual( json[ 0 ][ "name" ], "John", "Check JSON: first, name" );
2819 assert.strictEqual( json[ 0 ][ "age" ], 21, "Check JSON: first, age" );
2820 assert.strictEqual( json[ 1 ][ "name" ], "Peter", "Check JSON: second, name" );
2821 assert.strictEqual( json[ 1 ][ "age" ], 25, "Check JSON: second, age" );
2822 done();
2823 }
2824 );
2825 } );
2826
2827 QUnit.test( "jQuery.getJSON( String, Function ) - JSON object", function( assert ) {
2828 assert.expect( 2 );
2829 var done = assert.async();
2830 jQuery.getJSON( url( "mock.php?action=json" ), function( json ) {
2831 if ( json && json[ "data" ] ) {
2832 assert.strictEqual( json[ "data" ][ "lang" ], "en", "Check JSON: lang" );
2833 assert.strictEqual( json[ "data" ].length, 25, "Check JSON: length" );
2834 done();
2835 }
2836 } );
2837 } );
2838
2839 QUnit.test( "jQuery.getJSON( String, Function ) - JSON object with absolute url to local content", function( assert ) {
2840 assert.expect( 2 );
2841 var done = assert.async();
2842 var absoluteUrl = url( "mock.php?action=json" );
2843
2844 // Make a relative URL absolute relative to the document location
2845 if ( !/^[a-z][a-z0-9+.-]*:/i.test( absoluteUrl ) ) {
2846
2847 // An absolute path replaces everything after the host
2848 if ( absoluteUrl.charAt( 0 ) === "/" ) {
2849 absoluteUrl = window.location.href.replace( /(:\/*[^/]*).*$/, "$1" ) + absoluteUrl;
2850
2851 // A relative path replaces the last slash-separated path segment
2852 } else {
2853 absoluteUrl = window.location.href.replace( /[^/]*$/, "" ) + absoluteUrl;
2854 }
2855 }
2856
2857 jQuery.getJSON( absoluteUrl, function( json ) {
2858 assert.strictEqual( json.data.lang, "en", "Check JSON: lang" );
2859 assert.strictEqual( json.data.length, 25, "Check JSON: length" );
2860 done();
2861 } );
2862 } );
2863
2864 //----------- jQuery.getScript()
2865
2866 QUnit.test( "jQuery.getScript( String, Function ) - with callback",
2867 function( assert ) {
2868 assert.expect( 2 );
2869 var done = assert.async();
2870
2871 Globals.register( "testBar" );
2872 jQuery.getScript( url( "mock.php?action=testbar" ), function() {
2873 assert.strictEqual( window[ "testBar" ], "bar", "Check if script was evaluated" );
2874 done();
2875 } );
2876 }
2877 );
2878
2879 QUnit.test( "jQuery.getScript( String, Function ) - no callback", function( assert ) {
2880 assert.expect( 1 );
2881 Globals.register( "testBar" );
2882 jQuery.getScript( url( "mock.php?action=testbar" ) ).done( assert.async() );
2883 } );
2884
2885 QUnit.test( "trac-8082 - jQuery.getScript( String, Function ) - source as responseText", function( assert ) {
2886 assert.expect( 2 );
2887 var done = assert.async();
2888
2889 Globals.register( "testBar" );
2890 jQuery.getScript( url( "mock.php?action=testbar" ), function( data, _, jqXHR ) {
2891 assert.strictEqual( data, jqXHR.responseText, "Same-domain script requests returns the source of the script" );
2892 done();
2893 } );
2894 } );
2895
2896 QUnit.test( "jQuery.getScript( Object ) - with callback", function( assert ) {
2897 assert.expect( 2 );
2898 var done = assert.async();
2899
2900 Globals.register( "testBar" );
2901 jQuery.getScript( {
2902 url: url( "mock.php?action=testbar" ),
2903 success: function() {
2904 assert.strictEqual( window[ "testBar" ], "bar", "Check if script was evaluated" );
2905 done();
2906 }
2907 } );
2908 } );
2909
2910 QUnit.test( "jQuery.getScript( Object ) - no callback", function( assert ) {
2911 assert.expect( 1 );
2912 Globals.register( "testBar" );
2913 jQuery.getScript( { url: url( "mock.php?action=testbar" ) } ).done( assert.async() );
2914 } );
2915
2916 // //----------- jQuery.fn.load()
2917
2918 // check if load can be called with only url
2919 QUnit.test( "jQuery.fn.load( String )", function( assert ) {
2920 assert.expect( 2 );
2921 jQuery.ajaxSetup( {
2922 beforeSend: function() {
2923 assert.strictEqual( this.type, "GET", "no data means GET request" );
2924 }
2925 } );
2926 jQuery( "#first" ).load( baseURL + "name.html", assert.async() );
2927 } );
2928
2929 QUnit.test( "jQuery.fn.load() - 404 error callbacks", function( assert ) {
2930 assert.expect( 6 );
2931 var done = assert.async();
2932
2933 addGlobalEvents( "ajaxStart ajaxStop ajaxSend ajaxComplete ajaxError", assert )();
2934 jQuery( document ).on( "ajaxStop", done );
2935 jQuery( "<div></div>" ).load( baseURL + "404.txt", function() {
2936 assert.ok( true, "complete" );
2937 } );
2938 } );
2939
2940 // check if load can be called with url and null data
2941 QUnit.test( "jQuery.fn.load( String, null )", function( assert ) {
2942 assert.expect( 2 );
2943 jQuery.ajaxSetup( {
2944 beforeSend: function() {
2945 assert.strictEqual( this.type, "GET", "no data means GET request" );
2946 }
2947 } );
2948 jQuery( "#first" ).load( baseURL + "name.html", null, assert.async() );
2949 } );
2950
2951 // check if load can be called with url and undefined data
2952 QUnit.test( "jQuery.fn.load( String, undefined )", function( assert ) {
2953 assert.expect( 2 );
2954 jQuery.ajaxSetup( {
2955 beforeSend: function() {
2956 assert.strictEqual( this.type, "GET", "no data means GET request" );
2957 }
2958 } );
2959 jQuery( "#first" ).load( baseURL + "name.html", undefined, assert.async() );
2960 } );
2961
2962 // check if load can be called with only url
2963 QUnit.test( "jQuery.fn.load( URL_SELECTOR )", function( assert ) {
2964 assert.expect( 1 );
2965 var done = assert.async();
2966 jQuery( "#first" ).load( baseURL + "test3.html div.user", function() {
2967 assert.strictEqual( jQuery( this ).children( "div" ).length, 2, "Verify that specific elements were injected" );
2968 done();
2969 } );
2970 } );
2971
2972 // Selector should be trimmed to avoid leading spaces (trac-14773)
2973 QUnit.test( "jQuery.fn.load( URL_SELECTOR with spaces )", function( assert ) {
2974 assert.expect( 1 );
2975 var done = assert.async();
2976 jQuery( "#first" ).load( baseURL + "test3.html #superuser ", function() {
2977 assert.strictEqual( jQuery( this ).children( "div" ).length, 1, "Verify that specific elements were injected" );
2978 done();
2979 } );
2980 } );
2981
2982 // Selector should be trimmed to avoid leading spaces (trac-14773)
2983 // Selector should include any valid non-HTML whitespace (gh-3003)
2984 QUnit.test( "jQuery.fn.load( URL_SELECTOR with non-HTML whitespace(gh-3003) )", function( assert ) {
2985 assert.expect( 1 );
2986 var done = assert.async();
2987 jQuery( "#first" ).load( baseURL + "test3.html #whitespace\\\\xA0 ", function() {
2988 assert.strictEqual( jQuery( this ).children( "div" ).length, 1, "Verify that specific elements were injected" );
2989 done();
2990 } );
2991 } );
2992
2993 QUnit.test( "jQuery.fn.load( String, Function ) - simple: inject text into DOM", function( assert ) {
2994 assert.expect( 2 );
2995 var done = assert.async();
2996 jQuery( "#first" ).load( url( "name.html" ), function() {
2997 assert.ok( /^ERROR/.test( jQuery( "#first" ).text() ), "Check if content was injected into the DOM" );
2998 done();
2999 } );
3000 } );
3001
3002 QUnit.test( "jQuery.fn.load( String, Function ) - check scripts", function( assert ) {
3003 assert.expect( 7 );
3004 var done = assert.async();
3005 var verifyEvaluation = function() {
3006 assert.strictEqual( window[ "testBar" ], "bar", "Check if script src was evaluated after load" );
3007 assert.strictEqual( jQuery( "#ap" ).html(), "bar", "Check if script evaluation has modified DOM" );
3008 done();
3009 };
3010
3011 Globals.register( "testFoo" );
3012 Globals.register( "testBar" );
3013
3014 jQuery( "#first" ).load( url( "mock.php?action=testHTML&baseURL=" + baseURL ), function() {
3015 assert.ok( jQuery( "#first" ).html().match( /^html text/ ), "Check content after loading html" );
3016 assert.strictEqual( jQuery( "#foo" ).html(), "foo", "Check if script evaluation has modified DOM" );
3017 assert.strictEqual( window[ "testFoo" ], "foo", "Check if script was evaluated after load" );
3018 setTimeout( verifyEvaluation, 600 );
3019 } );
3020 } );
3021
3022 QUnit.test( "jQuery.fn.load( String, Function ) - check file with only a script tag", function( assert ) {
3023 assert.expect( 3 );
3024 var done = assert.async();
3025 Globals.register( "testFoo" );
3026
3027 jQuery( "#first" ).load( url( "test2.html" ), function() {
3028 assert.strictEqual( jQuery( "#foo" ).html(), "foo", "Check if script evaluation has modified DOM" );
3029 assert.strictEqual( window[ "testFoo" ], "foo", "Check if script was evaluated after load" );
3030 done();
3031 } );
3032 } );
3033
3034 QUnit.test( "jQuery.fn.load( String, Function ) - dataFilter in ajaxSettings", function( assert ) {
3035 assert.expect( 2 );
3036 var done = assert.async();
3037 jQuery.ajaxSetup( {
3038 dataFilter: function() {
3039 return "Hello World";
3040 }
3041 } );
3042 jQuery( "<div></div>" ).load( url( "name.html" ), function( responseText ) {
3043 assert.strictEqual( jQuery( this ).html(), "Hello World", "Test div was filled with filtered data" );
3044 assert.strictEqual( responseText, "Hello World", "Test callback receives filtered data" );
3045 done();
3046 } );
3047 } );
3048
3049 QUnit.test( "jQuery.fn.load( String, Object, Function )", function( assert ) {
3050 assert.expect( 2 );
3051 var done = assert.async();
3052 jQuery( "<div></div>" ).load( url( "mock.php?action=echoHtml" ), {
3053 "bar": "ok"
3054 }, function() {
3055 var $node = jQuery( this );
3056 assert.strictEqual( $node.find( "#method" ).text(), "POST", "Check method" );
3057 assert.strictEqual( $node.find( "#data" ).text(), "bar=ok", "Check if data is passed correctly" );
3058 done();
3059 } );
3060 } );
3061
3062 QUnit.test( "jQuery.fn.load( String, String, Function )", function( assert ) {
3063 assert.expect( 2 );
3064 var done = assert.async();
3065
3066 jQuery( "<div></div>" ).load( url( "mock.php?action=echoHtml" ), "foo=3&bar=ok", function() {
3067 var $node = jQuery( this );
3068 assert.strictEqual( $node.find( "#method" ).text(), "GET", "Check method" );
3069 assert.ok( $node.find( "#query" ).text().match( /foo=3&bar=ok/ ), "Check if a string of data is passed correctly" );
3070 done();
3071 } );
3072 } );
3073
3074 QUnit.test( "jQuery.fn.load() - callbacks get the correct parameters", function( assert ) {
3075 assert.expect( 8 );
3076 var completeArgs = {},
3077 done = assert.async();
3078
3079 jQuery.ajaxSetup( {
3080 success: function( _, status, jqXHR ) {
3081 completeArgs[ this.url ] = [ jqXHR.responseText, status, jqXHR ];
3082 },
3083 error: function( jqXHR, status ) {
3084 completeArgs[ this.url ] = [ jqXHR.responseText, status, jqXHR ];
3085 }
3086 } );
3087
3088 jQuery.when.apply(
3089 jQuery,
3090 jQuery.map( [
3091 {
3092 type: "success",
3093 url: baseURL + "mock.php?action=echoQuery&arg=pop"
3094 },
3095 {
3096 type: "error",
3097 url: baseURL + "404.txt"
3098 }
3099 ],
3100 function( options ) {
3101 return jQuery.Deferred( function( defer ) {
3102 jQuery( "#foo" ).load( options.url, function() {
3103 var args = arguments;
3104 assert.strictEqual( completeArgs[ options.url ].length, args.length, "same number of arguments (" + options.type + ")" );
3105 jQuery.each( completeArgs[ options.url ], function( i, value ) {
3106 assert.strictEqual( args[ i ], value, "argument #" + i + " is the same (" + options.type + ")" );
3107 } );
3108 defer.resolve();
3109 } );
3110 } );
3111 } )
3112 ).always( done );
3113 } );
3114
3115 QUnit.test( "trac-2046 - jQuery.fn.load( String, Function ) with ajaxSetup on dataType json", function( assert ) {
3116 assert.expect( 1 );
3117 var done = assert.async();
3118
3119 jQuery.ajaxSetup( {
3120 dataType: "json"
3121 } );
3122 jQuery( document ).on( "ajaxComplete", function( e, xml, s ) {
3123 assert.strictEqual( s.dataType, "html", "Verify the load() dataType was html" );
3124 jQuery( document ).off( "ajaxComplete" );
3125 done();
3126 } );
3127 jQuery( "#first" ).load( baseURL + "test3.html" );
3128 } );
3129
3130 QUnit.test( "trac-10524 - jQuery.fn.load() - data specified in ajaxSettings is merged in", function( assert ) {
3131 assert.expect( 1 );
3132 var done = assert.async();
3133
3134 var data = {
3135 "baz": 1
3136 };
3137 jQuery.ajaxSetup( {
3138 data: {
3139 "foo": "bar"
3140 }
3141 } );
3142 jQuery( "#foo" ).load( baseURL + "mock.php?action=echoQuery", data );
3143 jQuery( document ).on( "ajaxComplete", function( event, jqXHR, options ) {
3144 assert.ok( ~options.data.indexOf( "foo=bar" ), "Data from ajaxSettings was used" );
3145 done();
3146 } );
3147 } );
3148
3149 // //----------- jQuery.post()
3150
3151 QUnit.test( "jQuery.post() - data", function( assert ) {
3152 assert.expect( 3 );
3153 var done = assert.async();
3154
3155 jQuery.when(
3156 jQuery.post(
3157 url( "mock.php?action=xml" ),
3158 {
3159 cal: "5-2"
3160 },
3161 function( xml ) {
3162 jQuery( "math", xml ).each( function() {
3163 assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
3164 assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
3165 } );
3166 }
3167 ),
3168 jQuery.ajax( {
3169 url: url( "mock.php?action=echoData" ),
3170 type: "POST",
3171 data: {
3172 "test": {
3173 "length": 7,
3174 "foo": "bar"
3175 }
3176 },
3177 success: function( data ) {
3178 assert.strictEqual( data, "test%5Blength%5D=7&test%5Bfoo%5D=bar", "Check if a sub-object with a length param is serialized correctly" );
3179 }
3180 } )
3181 ).always( done );
3182 } );
3183
3184 QUnit.test( "jQuery.post( String, Hash, Function ) - simple with xml", function( assert ) {
3185 assert.expect( 4 );
3186 var done = assert.async();
3187
3188 jQuery.when(
3189 jQuery.post(
3190 url( "mock.php?action=xml" ),
3191 {
3192 cal: "5-2"
3193 },
3194 function( xml ) {
3195 jQuery( "math", xml ).each( function() {
3196 assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
3197 assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
3198 } );
3199 }
3200 ),
3201 jQuery.post( url( "mock.php?action=xml&cal=5-2" ), {}, function( xml ) {
3202 jQuery( "math", xml ).each( function() {
3203 assert.strictEqual( jQuery( "calculation", this ).text(), "5-2", "Check for XML" );
3204 assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
3205 } );
3206 } )
3207 ).always( function() {
3208 done();
3209 } );
3210 } );
3211
3212 QUnit.test( "jQuery[get|post]( options ) - simple with xml", function( assert ) {
3213 assert.expect( 2 );
3214 var done = assert.async();
3215
3216 jQuery.when.apply( jQuery,
3217 jQuery.map( [ "get", "post" ], function( method ) {
3218 return jQuery[ method ]( {
3219 url: url( "mock.php?action=xml" ),
3220 data: {
3221 cal: "5-2"
3222 },
3223 success: function( xml ) {
3224 jQuery( "math", xml ).each( function() {
3225 assert.strictEqual( jQuery( "result", this ).text(), "3", "Check for XML" );
3226 } );
3227 }
3228 } );
3229 } )
3230 ).always( function() {
3231 done();
3232 } );
3233 } );
3234
3235 //----------- jQuery.active
3236
3237 QUnit.test( "jQuery.active", function( assert ) {
3238 assert.expect( 1 );
3239 assert.ok( jQuery.active === 0, "ajax active counter should be zero: " + jQuery.active );
3240 } );
3241
3242 ajaxTest( "jQuery.ajax() - FormData", 1, function( assert ) {
3243 var formData = new FormData();
3244 formData.append( "key1", "value1" );
3245 formData.append( "key2", "value2" );
3246
3247 return {
3248 url: url( "mock.php?action=formData" ),
3249 method: "post",
3250 data: formData,
3251 success: function( data ) {
3252 assert.strictEqual( data, "key1 -> value1, key2 -> value2",
3253 "FormData sent correctly" );
3254 }
3255 };
3256 } );
3257
3258 ajaxTest( "jQuery.ajax() - URLSearchParams", 1, function( assert ) {
3259 var urlSearchParams = new URLSearchParams();
3260 urlSearchParams.append( "name", "peter" );
3261
3262 return {
3263 url: url( "mock.php?action=name" ),
3264 method: "post",
3265 data: urlSearchParams,
3266 success: function( data ) {
3267 assert.strictEqual( data, "pan", "URLSearchParams sent correctly" );
3268 }
3269 };
3270 }, QUnit.testUnlessIE );
3271
3272 ajaxTest( "jQuery.ajax() - Blob", 1, function( assert ) {
3273 var blob = new Blob( [ "name=peter" ], { type: "text/plain" } );
3274
3275 return {
3276 url: url( "mock.php?action=name" ),
3277 method: "post",
3278 data: blob,
3279 success: function( data ) {
3280 assert.strictEqual( data, "pan", "Blob sent correctly" );
3281 }
3282 };
3283 } );
3284
3285 ajaxTest( "jQuery.ajax() - non-plain object", 1, function( assert ) {
3286 return {
3287 url: url( "mock.php?action=name" ),
3288 method: "post",
3289 data: Object.create( { name: "peter" } ),
3290 success: function( data ) {
3291 assert.strictEqual( data, "ERROR", "Data correctly not sent" );
3292 }
3293 };
3294 } );
3295
3296 ajaxTest( "jQuery.ajax() - non-plain object with processData: true", 1, function( assert ) {
3297 return {
3298 url: url( "mock.php?action=name" ),
3299 method: "post",
3300 processData: true,
3301 data: Object.create( { name: "peter" } ),
3302 success: function( data ) {
3303 assert.strictEqual( data, "pan", "Data sent correctly" );
3304 }
3305 };
3306 } );
3307
3308 } )();
a fast, small, and feature-rich JavaScript library