test/unit/basic.js

   1 QUnit.module( "basic", { afterEach: moduleTeardown } );
   2
   3 if ( includesModule( "ajax" ) ) {
   4 QUnit.test( "ajax", function( assert ) {
   5         assert.expect( 4 );
   6
   7         var done = assert.async( 3 );
   8
   9         jQuery.ajax( {
  10                 type: "GET",
  11                 url: url( "mock.php?action=name&name=foo" ),
  12                 success: function( msg ) {
  13                         assert.strictEqual( msg, "bar", "Check for GET" );
  14                         done();
  15                 }
  16         } );
  17
  18         jQuery.ajax( {
  19                 type: "POST",
  20                 url: url( "mock.php?action=name" ),
  21                 data: "name=peter",
  22                 success: function( msg ) {
  23                         assert.strictEqual( msg, "pan", "Check for POST" );
  24                         done();
  25                 }
  26         } );
  27
  28         jQuery( "#first" ).load( url( "name.html" ), function() {
  29                 assert.ok( /^ERROR/.test( jQuery( "#first" ).text() ),
  30                         "Check if content was injected into the DOM" );
  31                 done();
  32         } );
  33 } );
  34 }
  35
  36 if ( includesModule( "attributes" ) ) {
  37 QUnit.test( "attributes", function( assert ) {
  38         assert.expect( 6 );
  39
  40         var a = jQuery( "<a></a>" ).appendTo( "#qunit-fixture" ),
  41                 input = jQuery( "<input/>" ).appendTo( "#qunit-fixture" );
  42
  43         assert.strictEqual( a.attr( "foo", "bar" ).attr( "foo" ), "bar", ".attr getter/setter" );
  44         assert.strictEqual( a.removeAttr( "foo" ).attr( "foo" ), undefined, ".removeAttr" );
  45         assert.strictEqual( a.prop( "href", "#5" ).prop( "href" ),
  46                 location.href.replace( /\#.*$/, "" ) + "#5",
  47                 ".prop getter/setter" );
  48
  49         a.addClass( "abc def ghj" ).removeClass( "def ghj" );
  50         assert.strictEqual( a.hasClass( "abc" ), true, ".(add|remove|has)Class, class present" );
  51         assert.strictEqual( a.hasClass( "def" ), false, ".(add|remove|has)Class, class missing" );
  52
  53         assert.strictEqual( input.val( "xyz" ).val(), "xyz", ".val getter/setter" );
  54 } );
  55 }
  56
  57 if ( includesModule( "css" ) ) {
  58 QUnit.test( "css", function( assert ) {
  59         assert.expect( 1 );
  60
  61         var div = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" );
  62
  63         assert.strictEqual( div.css( "width", "50px" ).css( "width" ), "50px", ".css getter/setter" );
  64 } );
  65 }
  66
  67 if ( includesModule( "css" ) ) {
  68 QUnit.test( "show/hide", function( assert ) {
  69         assert.expect( 2 );
  70
  71         var div = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" );
  72
  73         div.hide();
  74         assert.strictEqual( div.css( "display" ), "none", "div hidden" );
  75         div.show();
  76         assert.strictEqual( div.css( "display" ), "block", "div shown" );
  77 } );
  78 }
  79
  80 QUnit.test( "core", function( assert ) {
  81         assert.expect( 17 );
  82
  83         var elem = jQuery( "<div></div><span></span>" );
  84
  85         assert.strictEqual( elem.length, 2, "Correct number of elements" );
  86
  87         assert.ok( jQuery.isPlainObject( { "a": 2 } ), "jQuery.isPlainObject(object)" );
  88         assert.ok( !jQuery.isPlainObject( "foo" ), "jQuery.isPlainObject(String)" );
  89
  90         assert.ok( jQuery.isXMLDoc( jQuery.parseXML(
  91                 "<?xml version='1.0' encoding='UTF-8'?><foo bar='baz'></foo>"
  92         ) ), "jQuery.isXMLDoc" );
  93
  94         assert.strictEqual( jQuery.inArray( 3, [ "a", 6, false, 3, {} ] ), 3, "jQuery.inArray - true" );
  95         assert.strictEqual(
  96                 jQuery.inArray( 3, [ "a", 6, false, "3", {} ] ),
  97                 -1,
  98                 "jQuery.inArray - false"
  99         );
 100
 101         assert.strictEqual( elem.get( 1 ), elem[ 1 ], ".get" );
 102         assert.strictEqual( elem.first()[ 0 ], elem[ 0 ], ".first" );
 103         assert.strictEqual( elem.last()[ 0 ], elem[ 1 ], ".last" );
 104
 105         assert.deepEqual( jQuery.map( [ "a", "b", "c" ], function( v, k ) {
 106                 return k + v;
 107         } ), [ "0a", "1b", "2c" ], "jQuery.map" );
 108
 109         assert.deepEqual( jQuery.merge( [ 1, 2 ], [ "a", "b" ] ), [ 1, 2, "a", "b" ], "jQuery.merge" );
 110
 111         assert.deepEqual( jQuery.grep( [ 1, 2, 3 ], function( value ) {
 112                 return value % 2 !== 0;
 113         } ), [ 1, 3 ], "jQuery.grep" );
 114
 115         assert.deepEqual( jQuery.extend( { a: 2 }, { b: 3 } ), { a: 2, b: 3 }, "jQuery.extend" );
 116
 117         jQuery.each( [ 0, 2 ], function( k, v ) {
 118                 assert.strictEqual( k * 2, v, "jQuery.each" );
 119         } );
 120
 121         assert.deepEqual( jQuery.makeArray( { 0: "a", 1: "b", 2: "c", length: 3 } ),
 122                 [ "a", "b", "c" ], "jQuery.makeArray" );
 123
 124         assert.strictEqual( jQuery.parseHTML( "<div></div><span></span>" ).length,
 125                 2, "jQuery.parseHTML" );
 126 } );
 127
 128 if ( includesModule( "data" ) ) {
 129 QUnit.test( "data", function( assert ) {
 130         assert.expect( 4 );
 131
 132         var elem = jQuery( "<div data-c='d'></div>" ).appendTo( "#qunit-fixture" );
 133
 134         assert.ok( !jQuery.hasData( elem[ 0 ] ), "jQuery.hasData - false" );
 135         assert.strictEqual( elem.data( "a", "b" ).data( "a" ), "b", ".data getter/setter" );
 136         assert.strictEqual( elem.data( "c" ), "d", ".data from data-* attributes" );
 137         assert.ok( jQuery.hasData( elem[ 0 ] ), "jQuery.hasData - true" );
 138 } );
 139 }
 140
 141 if ( includesModule( "dimensions" ) ) {
 142 QUnit.test( "dimensions", function( assert ) {
 143         assert.expect( 3 );
 144
 145         var elem = jQuery(
 146                 "<div style='margin: 10px; padding: 7px; border: 2px solid black;'></div> "
 147         ).appendTo( "#qunit-fixture" );
 148
 149         assert.strictEqual( elem.width( 50 ).width(), 50, ".width getter/setter" );
 150         assert.strictEqual( elem.innerWidth(), 64, ".innerWidth getter" );
 151         assert.strictEqual( elem.outerWidth(), 68, ".outerWidth getter" );
 152 } );
 153 }
 154
 155 if ( includesModule( "event" ) ) {
 156 QUnit.test( "event", function( assert ) {
 157         assert.expect( 1 );
 158
 159         var elem = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" );
 160
 161         elem
 162                 .on( "click", function() {
 163                         assert.ok( false, "click should not fire" );
 164                 } )
 165                 .off( "click" )
 166                 .trigger( "click" )
 167                 .on( "click", function() {
 168                         assert.ok( true, "click should fire" );
 169                 } )
 170                 .trigger( "click" );
 171 } );
 172 }
 173
 174 if ( includesModule( "manipulation" ) ) {
 175 QUnit.test( "manipulation", function( assert ) {
 176         assert.expect( 5 );
 177
 178         var child,
 179                 elem1 = jQuery( "<div><span></span></div>" ).appendTo( "#qunit-fixture" ),
 180                 elem2 = jQuery( "<div></div>" ).appendTo( "#qunit-fixture" );
 181
 182         assert.strictEqual( elem1.text( "foo" ).text(), "foo", ".html getter/setter" );
 183
 184         assert.strictEqual(
 185                 elem1.html( "<span></span>" ).html(),
 186                 "<span></span>",
 187                 ".html getter/setter"
 188         );
 189
 190         assert.strictEqual(
 191                 elem1.append( elem2 )[ 0 ].childNodes[ elem1[ 0 ].childNodes.length - 1 ],
 192                 elem2[ 0 ],
 193                 ".append"
 194         );
 195         assert.strictEqual( elem1.prepend( elem2 )[ 0 ].childNodes[ 0 ], elem2[ 0 ], ".prepend" );
 196
 197         child = elem1.find( "span" );
 198         child.after( "<a></a>" );
 199         child.before( "<b></b>" );
 200
 201         assert.strictEqual(
 202                 elem1.html(),
 203                 "<div></div><b></b><span></span><a></a>",
 204                 ".after/.before"
 205         );
 206 } );
 207 }
 208
 209 if ( includesModule( "offset" ) ) {
 210
 211 // Support: jsdom 13.2+
 212 // jsdom returns 0 for offset-related properties
 213 QUnit[ /jsdom\//.test( navigator.userAgent ) ? "skip" : "test" ]( "offset", function( assert ) {
 214         assert.expect( 3 );
 215
 216         var parent = jQuery( "<div style='position:fixed;top:20px;'></div>" ).appendTo( "#qunit-fixture" ),
 217                 elem = jQuery( "<div style='position:absolute;top:5px;'></div>" ).appendTo( parent );
 218
 219         assert.strictEqual( elem.offset().top, 25, ".offset getter" );
 220         assert.strictEqual( elem.position().top, 5, ".position getter" );
 221         assert.strictEqual( elem.offsetParent()[ 0 ], parent[ 0 ], ".offsetParent" );
 222 } );
 223 }
 224
 225 QUnit.test( "selector", function( assert ) {
 226         assert.expect( 2 );
 227
 228         var elem = jQuery( "<div><span class='a'></span><span class='b'><a></a></span></div>" )
 229                 .appendTo( "#qunit-fixture" );
 230
 231         assert.strictEqual( elem.find( ".a a" ).length, 0, ".find - no result" );
 232         assert.strictEqual( elem.find( "span.b a" )[ 0 ].nodeName, "A", ".find - one result" );
 233 } );
 234
 235 if ( includesModule( "serialize" ) ) {
 236 QUnit.test( "serialize", function( assert ) {
 237         assert.expect( 2 );
 238
 239         var params = { "someName": [ 1, 2, 3 ], "regularThing": "blah" };
 240         assert.strictEqual( jQuery.param( params ),
 241                 "someName%5B%5D=1&someName%5B%5D=2&someName%5B%5D=3&regularThing=blah",
 242                 "jQuery.param" );
 243
 244         assert.strictEqual( jQuery( "#form" ).serialize(),
 245                 "action=Test&radio2=on&check=on&hidden=&foo%5Bbar%5D=&name=name&search=search" +
 246                 "&select1=&select2=3&select3=1&select3=2&select5=3",
 247                 "form serialization as query string" );
 248 } );
 249 }
 250
 251 QUnit.test( "traversing", function( assert ) {
 252         assert.expect( 12 );
 253
 254         var elem = jQuery( "<div><a><b><em></em></b></a><i></i><span></span>foo</div>" )
 255                 .appendTo( "#qunit-fixture" );
 256
 257         assert.strictEqual( elem.find( "em" ).parent()[ 0 ].nodeName, "B", ".parent" );
 258         assert.strictEqual( elem.find( "em" ).parents()[ 1 ].nodeName, "A", ".parents" );
 259         assert.strictEqual( elem.find( "em" ).parentsUntil( "div" ).length, 2, ".parentsUntil" );
 260         assert.strictEqual( elem.find( "i" ).next()[ 0 ].nodeName, "SPAN", ".next" );
 261         assert.strictEqual( elem.find( "i" ).prev()[ 0 ].nodeName, "A", ".prev" );
 262         assert.strictEqual( elem.find( "a" ).nextAll()[ 1 ].nodeName, "SPAN", ".nextAll" );
 263         assert.strictEqual( elem.find( "span" ).prevAll()[ 1 ].nodeName, "A", ".prevAll" );
 264         assert.strictEqual( elem.find( "a" ).nextUntil( "span" ).length, 1, ".nextUntil" );
 265         assert.strictEqual( elem.find( "span" ).prevUntil( "a" ).length, 1, ".prevUntil" );
 266         assert.strictEqual( elem.find( "i" ).siblings().length, 2, ".siblings" );
 267         assert.strictEqual( elem.children()[ 2 ].nodeName, "SPAN", ".children" );
 268         assert.strictEqual( elem.contents()[ 3 ].nodeType, 3, ".contents" );
 269 } );
 270
 271 if ( includesModule( "wrap" ) ) {
 272 QUnit.test( "wrap", function( assert ) {
 273         assert.expect( 3 );
 274
 275         var elem = jQuery( "<div><a><b></b></a><a></a></div>" );
 276
 277         elem.find( "b" ).wrap( "<span>" );
 278
 279         assert.strictEqual(
 280                 elem.html(),
 281                 "<a><span><b></b></span></a><a></a>",
 282                 ".wrap"
 283         );
 284
 285         elem.find( "span" ).wrapInner( "<em>" );
 286
 287         assert.strictEqual(
 288                 elem.html(),
 289                 "<a><span><em><b></b></em></span></a><a></a>",
 290                 ".wrapInner"
 291         );
 292
 293         elem.find( "a" ).wrapAll( "<i>" );
 294
 295         assert.strictEqual(
 296                 elem.html(),
 297                 "<i><a><span><em><b></b></em></span></a><a></a></i>",
 298                 ".wrapAll"
 299         );
 300
 301 } );
 302 }