test/test.js

   1 test("module without setup/teardown (default)", function() {
   2         expect(1);
   3         ok(true);
   4 });
   5
   6 test("expect in test", 3, function() {
   7         ok(true);
   8         ok(true);
   9         ok(true);
  10 });
  11
  12 test("expect in test", 1, function() {
  13         ok(true);
  14 });
  15
  16 test("expect query and multiple issue", function() {
  17         expect(2);
  18         ok(true);
  19         var expected = expect();
  20         equal(expected, 2);
  21         expect(expected + 1);
  22         ok(true);
  23 });
  24
  25 QUnit.module("assertion helpers");
  26
  27 QUnit.test( "QUnit.assert compatibility", function( assert ) {
  28         QUnit.expect(4);
  29
  30         assert.ok( true, "Calling method on `assert` argument to test() callback" );
  31
  32         // Should also work, although not documented
  33         QUnit.assert.ok( true, "Calling method on QUnit.assert object" );
  34
  35         // Test compatibility aliases
  36         QUnit.ok( true, "Calling aliased method in QUnit root object" );
  37         ok( true, "Calling aliased function in global namespace" );
  38 });
  39
  40 module("setup test", {
  41         setup: function() {
  42                 ok(true);
  43         }
  44 });
  45
  46 test("module with setup", function() {
  47         expect(2);
  48         ok(true);
  49 });
  50
  51 test("module with setup, expect in test call", 2, function() {
  52         ok(true);
  53 });
  54
  55 var state;
  56
  57 module("setup/teardown test", {
  58         setup: function() {
  59                 state = true;
  60                 ok(true);
  61                 window.x = 1;
  62         },
  63         teardown: function() {
  64                 ok(true);
  65                 // can introduce and delete globals in setup/teardown
  66                 // without noglobals sounding the alarm
  67                 delete window.x;
  68         }
  69 });
  70
  71 test("module with setup/teardown", function() {
  72         expect(3);
  73         ok(true);
  74 });
  75
  76 module("setup/teardown test 2");
  77
  78 test("module without setup/teardown", function() {
  79         expect(1);
  80         ok(true);
  81 });
  82
  83
  84
  85 var orgDate;
  86
  87 module("Date test", {
  88         setup: function() {
  89                 orgDate = Date;
  90                 Date = function () {
  91                         ok( false, 'QUnit should internally be independant from Date-related manipulation and testing' );
  92                         return new orgDate();
  93                 };
  94         },
  95         teardown: function() {
  96                 Date = orgDate;
  97         }
  98 });
  99
 100 test("sample test for Date test", function () {
 101         expect(1);
 102         ok(true);
 103 });
 104
 105 if (typeof setTimeout !== 'undefined') {
 106 state = 'fail';
 107
 108 module("teardown and stop", {
 109         teardown: function() {
 110                 equal(state, "done", "Test teardown.");
 111         }
 112 });
 113
 114 test("teardown must be called after test ended", function() {
 115         expect(1);
 116         stop();
 117         setTimeout(function() {
 118                 state = "done";
 119                 start();
 120         }, 13);
 121 });
 122
 123 test("parameter passed to stop increments semaphore n times", function() {
 124         expect(1);
 125         stop(3);
 126         setTimeout(function() {
 127                 state = "not enough starts";
 128                 start(), start();
 129         }, 13);
 130         setTimeout(function() {
 131                 state = "done";
 132                 start();
 133         }, 15);
 134 });
 135
 136 test("parameter passed to start decrements semaphore n times", function() {
 137         expect(1);
 138         stop(), stop(), stop();
 139         setTimeout(function() {
 140                 state = "done";
 141                 start(3);
 142         }, 18);
 143 });
 144
 145 module("async setup test", {
 146         setup: function() {
 147                 stop();
 148                 setTimeout(function() {
 149                         ok(true);
 150                         start();
 151                 }, 500);
 152         }
 153 });
 154
 155 asyncTest("module with async setup", function() {
 156         expect(2);
 157         ok(true);
 158         start();
 159 });
 160
 161 module("async teardown test", {
 162         teardown: function() {
 163                 stop();
 164                 setTimeout(function() {
 165                         ok(true);
 166                         start();
 167                 }, 500);
 168         }
 169 });
 170
 171 asyncTest("module with async teardown", function() {
 172         expect(2);
 173         ok(true);
 174         start();
 175 });
 176
 177 module("asyncTest");
 178
 179 asyncTest("asyncTest", function() {
 180         expect(2);
 181         ok(true);
 182         setTimeout(function() {
 183                 state = "done";
 184                 ok(true);
 185                 start();
 186         }, 13);
 187 });
 188
 189 asyncTest("asyncTest", 2, function() {
 190         ok(true);
 191         setTimeout(function() {
 192                 state = "done";
 193                 ok(true);
 194                 start();
 195         }, 13);
 196 });
 197
 198 test("sync", 2, function() {
 199         stop();
 200         setTimeout(function() {
 201                 ok(true);
 202                 start();
 203         }, 13);
 204         stop();
 205         setTimeout(function() {
 206                 ok(true);
 207                 start();
 208         }, 125);
 209 });
 210
 211 test("test synchronous calls to stop", 2, function() {
 212         stop();
 213         setTimeout(function() {
 214                 ok(true, 'first');
 215                 start();
 216                 stop();
 217                 setTimeout(function() {
 218                         ok(true, 'second');
 219                         start();
 220                 }, 150);
 221         }, 150);
 222 });
 223 }
 224
 225 module("save scope", {
 226         setup: function() {
 227                 this.foo = "bar";
 228         },
 229         teardown: function() {
 230                 deepEqual(this.foo, "bar");
 231         }
 232 });
 233 test("scope check", function() {
 234         expect(2);
 235         deepEqual(this.foo, "bar");
 236 });
 237
 238 module("simple testEnvironment setup", {
 239         foo: "bar",
 240         // example of meta-data
 241         bugid: "#5311"
 242 });
 243 test("scope check", function() {
 244         deepEqual(this.foo, "bar");
 245 });
 246 test("modify testEnvironment",function() {
 247         expect(0);
 248         this.foo="hamster";
 249 });
 250 test("testEnvironment reset for next test",function() {
 251         deepEqual(this.foo, "bar");
 252 });
 253
 254 module("testEnvironment with object", {
 255         options:{
 256                 recipe:"soup",
 257                 ingredients:["hamster","onions"]
 258         }
 259 });
 260 test("scope check", function() {
 261         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions"]}) ;
 262 });
 263 test("modify testEnvironment",function() {
 264         expect(0);
 265         // since we do a shallow copy, the testEnvironment can be modified
 266         this.options.ingredients.push("carrots");
 267 });
 268 test("testEnvironment reset for next test",function() {
 269         deepEqual(this.options, {recipe:"soup",ingredients:["hamster","onions","carrots"]}, "Is this a bug or a feature? Could do a deep copy") ;
 270 });
 271
 272
 273 module("testEnvironment tests");
 274
 275 function makeurl() {
 276         var testEnv = QUnit.current_testEnvironment;
 277         var url = testEnv.url || 'http://example.com/search';
 278         var q   = testEnv.q   || 'a search test';
 279         return url + '?q='+encodeURIComponent(q);
 280 }
 281
 282 test("makeurl working",function() {
 283         equal( QUnit.current_testEnvironment, this, 'The current testEnvironment is global');
 284         equal( makeurl(), 'http://example.com/search?q=a%20search%20test', 'makeurl returns a default url if nothing specified in the testEnvironment');
 285 });
 286
 287 module("testEnvironment with makeurl settings", {
 288         url: 'http://google.com/',
 289         q: 'another_search_test'
 290 });
 291 test("makeurl working with settings from testEnvironment", function() {
 292         equal( makeurl(), 'http://google.com/?q=another_search_test', 'rather than passing arguments, we use test metadata to from the url');
 293 });
 294
 295 module("jsDump");
 296 test("jsDump output", function() {
 297         equal( QUnit.jsDump.parse([1, 2]), "[\n  1,\n  2\n]" );
 298         equal( QUnit.jsDump.parse({top: 5, left: 0}), "{\n  \"left\": 0,\n  \"top\": 5\n}" );
 299         if (typeof document !== 'undefined' && document.getElementById("qunit-header")) {
 300                 equal( QUnit.jsDump.parse(document.getElementById("qunit-header")), "<h1 id=\"qunit-header\"></h1>" );
 301                 equal( QUnit.jsDump.parse(document.getElementsByTagName("h1")), "[\n  <h1 id=\"qunit-header\"></h1>\n]" );
 302         }
 303 });
 304
 305 module("assertions");
 306 test("raises",function() {
 307         function CustomError( message ) {
 308                 this.message = message;
 309         }
 310
 311         CustomError.prototype.toString = function() {
 312                 return this.message;
 313         };
 314
 315         throws(
 316                 function() {
 317                         throw "my error";
 318                 }
 319         );
 320
 321         throws(
 322                 function() {
 323                         throw "my error";
 324                 },
 325                 "simple string throw, no 'expected' value given"
 326         );
 327
 328         throws(
 329                 function() {
 330                         throw new CustomError();
 331                 },
 332                 CustomError,
 333                 'thrown error is an instance of CustomError'
 334         );
 335
 336         throws(
 337                 function() {
 338                         throw new CustomError("some error description");
 339                 },
 340                 /description/,
 341                 "use a regex to match against the stringified error"
 342         );
 343
 344         throws(
 345                 function() {
 346                         throw new CustomError("some error description");
 347                 },
 348                 function( err ) {
 349                         if ( (err instanceof CustomError) && /description/.test(err) ) {
 350                                 return true;
 351                         }
 352                 },
 353                 "custom validation function"
 354         );
 355
 356         throws(
 357                 function() {
 358                         /*jshint evil:true */
 359                         ( window.execScript || function( data ) {
 360                                 window["eval"].call( window, data );
 361                         })( "throw 'error';" );
 362                 },
 363                 'globally-executed errors caught'
 364         );
 365
 366     this.CustomError = CustomError;
 367
 368     throws(
 369         function() {
 370             throw new this.CustomError("some error description");
 371         },
 372         /description/,
 373         "throw error from property of 'this' context"
 374     );
 375
 376     raises(
 377         function() {
 378             throw "error";
 379         },
 380         "simple throw, asserting with deprecated raises() function"
 381     );
 382
 383 });
 384
 385 if (typeof document !== "undefined") {
 386
 387 module("fixture");
 388 test("setup", function() {
 389         expect(0);
 390         document.getElementById("qunit-fixture").innerHTML = "foobar";
 391 });
 392 test("basics", function() {
 393         equal( document.getElementById("qunit-fixture").innerHTML, "test markup", "automatically reset" );
 394 });
 395
 396 test("running test name displayed", function() {
 397         expect(2);
 398
 399         var displaying = document.getElementById("qunit-testresult");
 400
 401         ok( /running test name displayed/.test(displaying.innerHTML), "Expect test name to be found in displayed text" );
 402         ok( /fixture/.test(displaying.innerHTML), "Expect module name to be found in displayed text" );
 403 });
 404
 405 }
 406
 407 module("custom assertions");
 408 (function() {
 409         function mod2(value, expected, message) {
 410                 var actual = value % 2;
 411                 QUnit.push(actual == expected, actual, expected, message);
 412         }
 413         test("mod2", function() {
 414                 mod2(2, 0, "2 % 2 == 0");
 415                 mod2(3, 1, "3 % 2 == 1");
 416         });
 417 })();
 418
 419
 420 module("recursions");
 421
 422 function Wrap(x) {
 423         this.wrap = x;
 424         if (x === undefined) {
 425                 this.first = true;
 426         }
 427 }
 428
 429 function chainwrap(depth, first, prev) {
 430         depth = depth || 0;
 431         var last = prev || new Wrap();
 432         first = first || last;
 433
 434         if (depth == 1) {
 435                 first.wrap = last;
 436         }
 437         if (depth > 1) {
 438                 last = chainwrap(depth-1, first, new Wrap(last));
 439         }
 440
 441         return last;
 442 }
 443
 444 test("check jsDump recursion", function() {
 445         expect(4);
 446
 447         var noref = chainwrap(0);
 448         var nodump = QUnit.jsDump.parse(noref);
 449         equal(nodump, '{\n  "first": true,\n  "wrap": undefined\n}');
 450
 451         var selfref = chainwrap(1);
 452         var selfdump = QUnit.jsDump.parse(selfref);
 453         equal(selfdump, '{\n  "first": true,\n  "wrap": recursion(-1)\n}');
 454
 455         var parentref = chainwrap(2);
 456         var parentdump = QUnit.jsDump.parse(parentref);
 457         equal(parentdump, '{\n  "wrap": {\n    "first": true,\n    "wrap": recursion(-2)\n  }\n}');
 458
 459         var circref = chainwrap(10);
 460         var circdump = QUnit.jsDump.parse(circref);
 461         ok(new RegExp("recursion\\(-10\\)").test(circdump), "(" +circdump + ") should show -10 recursion level");
 462 });
 463
 464 test("check (deep-)equal recursion", function() {
 465         var noRecursion = chainwrap(0);
 466         equal(noRecursion, noRecursion, "I should be equal to me.");
 467         deepEqual(noRecursion, noRecursion, "... and so in depth.");
 468
 469         var selfref = chainwrap(1);
 470         equal(selfref, selfref, "Even so if I nest myself.");
 471         deepEqual(selfref, selfref, "... into the depth.");
 472
 473         var circref = chainwrap(10);
 474         equal(circref, circref, "Or hide that through some levels of indirection.");
 475         deepEqual(circref, circref, "... and checked on all levels!");
 476 });
 477
 478
 479 test('Circular reference with arrays', function() {
 480
 481         // pure array self-ref
 482         var arr = [];
 483         arr.push(arr);
 484
 485         var arrdump = QUnit.jsDump.parse(arr);
 486
 487         equal(arrdump, '[\n  recursion(-1)\n]');
 488         equal(arr, arr[0], 'no endless stack when trying to dump arrays with circular ref');
 489
 490
 491         // mix obj-arr circular ref
 492         var obj = {};
 493         var childarr = [obj];
 494         obj.childarr = childarr;
 495
 496         var objdump = QUnit.jsDump.parse(obj);
 497         var childarrdump = QUnit.jsDump.parse(childarr);
 498
 499         equal(objdump, '{\n  "childarr": [\n    recursion(-2)\n  ]\n}');
 500         equal(childarrdump, '[\n  {\n    "childarr": recursion(-2)\n  }\n]');
 501
 502         equal(obj.childarr, childarr, 'no endless stack when trying to dump array/object mix with circular ref');
 503         equal(childarr[0], obj, 'no endless stack when trying to dump array/object mix with circular ref');
 504
 505 });
 506
 507
 508 test('Circular reference - test reported by soniciq in #105', function() {
 509         var MyObject = function() {};
 510         MyObject.prototype.parent = function(obj) {
 511                 if (obj === undefined) { return this._parent; }
 512                 this._parent = obj;
 513         };
 514         MyObject.prototype.children = function(obj) {
 515                 if (obj === undefined) { return this._children; }
 516                 this._children = obj;
 517         };
 518
 519         var a = new MyObject(),
 520                 b = new MyObject();
 521
 522         var barr = [b];
 523         a.children(barr);
 524         b.parent(a);
 525
 526         equal(a.children(), barr);
 527         deepEqual(a.children(), [b]);
 528 });
 529
 530 (function() {
 531         var reset = QUnit.reset;
 532         module("reset");
 533         test("reset runs assertions", function() {
 534                 expect(0);
 535                 QUnit.reset = function() {
 536                         ok( false, "reset should not modify test status" );
 537                         reset.apply( this, arguments );
 538                 };
 539         });
 540         test("reset runs assertions, cleanup", function() {
 541                 expect(0);
 542                 QUnit.reset = reset;
 543         });
 544 })();
 545
 546 function testAfterDone() {
 547         var testName = "ensure has correct number of assertions";
 548
 549         function secondAfterDoneTest() {
 550                 QUnit.config.done = [];
 551                 // Because when this does happen, the assertion count parameter doesn't actually
 552                 // work we use this test to check the assertion count.
 553                 module("check previous test's assertion counts");
 554                 test('count previous two test\'s assertions', function () {
 555                         var i, countNodes,
 556                                 spans = document.getElementsByTagName('span'),
 557                                 tests = [];
 558
 559                         // Find these two tests
 560                         for (i = 0; i < spans.length; i++) {
 561                                 if (spans[i].innerHTML.indexOf(testName) !== -1) {
 562                                         tests.push(spans[i]);
 563                                 }
 564                         }
 565
 566                         // Walk dom to counts.
 567                         countNodes = tests[0].nextSibling.nextSibling.getElementsByTagName('b');
 568                         equal(countNodes[1].innerHTML, "99");
 569                         countNodes = tests[1].nextSibling.nextSibling.getElementsByTagName('b');
 570                         equal(countNodes[1].innerHTML, "99");
 571                 });
 572         }
 573         QUnit.config.done = [];
 574         QUnit.done(secondAfterDoneTest);
 575
 576         module("Synchronous test after load of page");
 577
 578         asyncTest('Async test', function() {
 579                 start();
 580                 for (var i = 1; i < 100; i++) {
 581                         ok(i);
 582                 }
 583         });
 584
 585         test(testName, 99, function() {
 586                 for (var i = 1; i < 100; i++) {
 587                         ok(i);
 588                 }
 589         });
 590
 591         // We need two of these types of tests in order to ensure that assertions
 592         // don't move between tests.
 593         test(testName + ' 2', 99, function() {
 594                 for (var i = 1; i < 100; i++) {
 595                         ok(i);
 596                 }
 597         });
 598
 599
 600 }
 601
 602 if (typeof setTimeout !== 'undefined') {
 603         QUnit.done(testAfterDone);
 604 }