res/js/unittest.js

   1 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
   2 //           (c) 2005 Jon Tirsen (http://www.tirsen.com)
   3 //           (c) 2005 Michael Schuerig (http://www.schuerig.de/michael/)
   4 //
   5 // Permission is hereby granted, free of charge, to any person obtaining
   6 // a copy of this software and associated documentation files (the
   7 // "Software"), to deal in the Software without restriction, including
   8 // without limitation the rights to use, copy, modify, merge, publish,
   9 // distribute, sublicense, and/or sell copies of the Software, and to
  10 // permit persons to whom the Software is furnished to do so, subject to
  11 // the following conditions:
  12 //
  13 // The above copyright notice and this permission notice shall be
  14 // included in all copies or substantial portions of the Software.
  15 //
  16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24
  25 // experimental, Firefox-only
  26 Event.simulateMouse = function(element, eventName) {
  27   var options = Object.extend({
  28     pointerX: 0,
  29     pointerY: 0,
  30     buttons: 0
  31   }, arguments[2] || {});
  32   var oEvent = document.createEvent("MouseEvents");
  33   oEvent.initMouseEvent(eventName, true, true, document.defaultView,
  34     options.buttons, options.pointerX, options.pointerY, options.pointerX, options.pointerY,
  35     false, false, false, false, 0, $(element));
  36
  37   if(this.mark) Element.remove(this.mark);
  38   this.mark = document.createElement('div');
  39   this.mark.appendChild(document.createTextNode(" "));
  40   document.body.appendChild(this.mark);
  41   this.mark.style.position = 'absolute';
  42   this.mark.style.top = options.pointerY + "px";
  43   this.mark.style.left = options.pointerX + "px";
  44   this.mark.style.width = "5px";
  45   this.mark.style.height = "5px;";
  46   this.mark.style.borderTop = "1px solid red;"
  47   this.mark.style.borderLeft = "1px solid red;"
  48
  49   if(this.step)
  50     alert('['+new Date().getTime().toString()+'] '+eventName+'/'+Test.Unit.inspect(options));
  51
  52   $(element).dispatchEvent(oEvent);
  53 };
  54
  55 // Note: Due to a fix in Firefox 1.0.5/6 that probably fixed "too much", this doesn't work in 1.0.6 or DP2.
  56 // You need to downgrade to 1.0.4 for now to get this working
  57 // See https://bugzilla.mozilla.org/show_bug.cgi?id=289940 for the fix that fixed too much
  58 Event.simulateKey = function(element, eventName) {
  59   var options = Object.extend({
  60     ctrlKey: false,
  61     altKey: false,
  62     shiftKey: false,
  63     metaKey: false,
  64     keyCode: 0,
  65     charCode: 0
  66   }, arguments[2] || {});
  67
  68   var oEvent = document.createEvent("KeyEvents");
  69   oEvent.initKeyEvent(eventName, true, true, window,
  70     options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
  71     options.keyCode, options.charCode );
  72   $(element).dispatchEvent(oEvent);
  73 };
  74
  75 Event.simulateKeys = function(element, command) {
  76   for(var i=0; i<command.length; i++) {
  77     Event.simulateKey(element,'keypress',{charCode:command.charCodeAt(i)});
  78   }
  79 };
  80
  81 var Test = {}
  82 Test.Unit = {};
  83
  84 // security exception workaround
  85 Test.Unit.inspect = Object.inspect;
  86
  87 Test.Unit.Logger = Class.create();
  88 Test.Unit.Logger.prototype = {
  89   initialize: function(log) {
  90     this.log = $(log);
  91     if (this.log) {
  92       this._createLogTable();
  93     }
  94   },
  95   start: function(testName) {
  96     if (!this.log) return;
  97     this.testName = testName;
  98     this.lastLogLine = document.createElement('tr');
  99     this.statusCell = document.createElement('td');
 100     this.nameCell = document.createElement('td');
 101     this.nameCell.appendChild(document.createTextNode(testName));
 102     this.messageCell = document.createElement('td');
 103     this.lastLogLine.appendChild(this.statusCell);
 104     this.lastLogLine.appendChild(this.nameCell);
 105     this.lastLogLine.appendChild(this.messageCell);
 106     this.loglines.appendChild(this.lastLogLine);
 107   },
 108   finish: function(status, summary) {
 109     if (!this.log) return;
 110     this.lastLogLine.className = status;
 111     this.statusCell.innerHTML = status;
 112     this.messageCell.innerHTML = this._toHTML(summary);
 113   },
 114   message: function(message) {
 115     if (!this.log) return;
 116     this.messageCell.innerHTML = this._toHTML(message);
 117   },
 118   summary: function(summary) {
 119     if (!this.log) return;
 120     this.logsummary.innerHTML = this._toHTML(summary);
 121   },
 122   _createLogTable: function() {
 123     this.log.innerHTML =
 124     '<div id="logsummary"></div>' +
 125     '<table id="logtable">' +
 126     '<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +
 127     '<tbody id="loglines"></tbody>' +
 128     '</table>';
 129     this.logsummary = $('logsummary')
 130     this.loglines = $('loglines');
 131   },
 132   _toHTML: function(txt) {
 133     return txt.escapeHTML().replace(/\n/g,"<br/>");
 134   }
 135 }
 136
 137 Test.Unit.Runner = Class.create();
 138 Test.Unit.Runner.prototype = {
 139   initialize: function(testcases) {
 140     this.options = Object.extend({
 141       testLog: 'testlog'
 142     }, arguments[1] || {});
 143     this.options.resultsURL = this.parseResultsURLQueryParameter();
 144     if (this.options.testLog) {
 145       this.options.testLog = $(this.options.testLog) || null;
 146     }
 147     if(this.options.tests) {
 148       this.tests = [];
 149       for(var i = 0; i < this.options.tests.length; i++) {
 150         if(/^test/.test(this.options.tests[i])) {
 151           this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));
 152         }
 153       }
 154     } else {
 155       if (this.options.test) {
 156         this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];
 157       } else {
 158         this.tests = [];
 159         for(var testcase in testcases) {
 160           if(/^test/.test(testcase)) {
 161             this.tests.push(new Test.Unit.Testcase(testcase, testcases[testcase], testcases["setup"], testcases["teardown"]));
 162           }
 163         }
 164       }
 165     }
 166     this.currentTest = 0;
 167     this.logger = new Test.Unit.Logger(this.options.testLog);
 168     setTimeout(this.runTests.bind(this), 1000);
 169   },
 170   parseResultsURLQueryParameter: function() {
 171     return window.location.search.parseQuery()["resultsURL"];
 172   },
 173   // Returns:
 174   //  "ERROR" if there was an error,
 175   //  "FAILURE" if there was a failure, or
 176   //  "SUCCESS" if there was neither
 177   getResult: function() {
 178     var hasFailure = false;
 179     for(var i=0;i<this.tests.length;i++) {
 180       if (this.tests[i].errors > 0) {
 181         return "ERROR";
 182       }
 183       if (this.tests[i].failures > 0) {
 184         hasFailure = true;
 185       }
 186     }
 187     if (hasFailure) {
 188       return "FAILURE";
 189     } else {
 190       return "SUCCESS";
 191     }
 192   },
 193   postResults: function() {
 194     if (this.options.resultsURL) {
 195       new Ajax.Request(this.options.resultsURL,
 196         { method: 'get', parameters: 'result=' + this.getResult(), asynchronous: false });
 197     }
 198   },
 199   runTests: function() {
 200     var test = this.tests[this.currentTest];
 201     if (!test) {
 202       // finished!
 203       this.postResults();
 204       this.logger.summary(this.summary());
 205       return;
 206     }
 207     if(!test.isWaiting) {
 208       this.logger.start(test.name);
 209     }
 210     test.run();
 211     if(test.isWaiting) {
 212       this.logger.message("Waiting for " + test.timeToWait + "ms");
 213       setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
 214     } else {
 215       this.logger.finish(test.status(), test.summary());
 216       this.currentTest++;
 217       // tail recursive, hopefully the browser will skip the stackframe
 218       this.runTests();
 219     }
 220   },
 221   summary: function() {
 222     var assertions = 0;
 223     var failures = 0;
 224     var errors = 0;
 225     var messages = [];
 226     for(var i=0;i<this.tests.length;i++) {
 227       assertions +=   this.tests[i].assertions;
 228       failures   +=   this.tests[i].failures;
 229       errors     +=   this.tests[i].errors;
 230     }
 231     return (
 232       this.tests.length + " tests, " +
 233       assertions + " assertions, " +
 234       failures   + " failures, " +
 235       errors     + " errors");
 236   }
 237 }
 238
 239 Test.Unit.Assertions = Class.create();
 240 Test.Unit.Assertions.prototype = {
 241   initialize: function() {
 242     this.assertions = 0;
 243     this.failures   = 0;
 244     this.errors     = 0;
 245     this.messages   = [];
 246   },
 247   summary: function() {
 248     return (
 249       this.assertions + " assertions, " +
 250       this.failures   + " failures, " +
 251       this.errors     + " errors" + "\n" +
 252       this.messages.join("\n"));
 253   },
 254   pass: function() {
 255     this.assertions++;
 256   },
 257   fail: function(message) {
 258     this.failures++;
 259     this.messages.push("Failure: " + message);
 260   },
 261   info: function(message) {
 262     this.messages.push("Info: " + message);
 263   },
 264   error: function(error) {
 265     this.errors++;
 266     this.messages.push(error.name + ": "+ error.message + "(" + Test.Unit.inspect(error) +")");
 267   },
 268   status: function() {
 269     if (this.failures > 0) return 'failed';
 270     if (this.errors > 0) return 'error';
 271     return 'passed';
 272   },
 273   assert: function(expression) {
 274     var message = arguments[1] || 'assert: got "' + Test.Unit.inspect(expression) + '"';
 275     try { expression ? this.pass() :
 276       this.fail(message); }
 277     catch(e) { this.error(e); }
 278   },
 279   assertEqual: function(expected, actual) {
 280     var message = arguments[2] || "assertEqual";
 281     try { (expected == actual) ? this.pass() :
 282       this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 283         '", actual "' + Test.Unit.inspect(actual) + '"'); }
 284     catch(e) { this.error(e); }
 285   },
 286   assertEnumEqual: function(expected, actual) {
 287     var message = arguments[2] || "assertEnumEqual";
 288     try { $A(expected).length == $A(actual).length &&
 289       expected.zip(actual).all(function(pair) { return pair[0] == pair[1] }) ?
 290         this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) +
 291           ', actual ' + Test.Unit.inspect(actual)); }
 292     catch(e) { this.error(e); }
 293   },
 294   assertNotEqual: function(expected, actual) {
 295     var message = arguments[2] || "assertNotEqual";
 296     try { (expected != actual) ? this.pass() :
 297       this.fail(message + ': got "' + Test.Unit.inspect(actual) + '"'); }
 298     catch(e) { this.error(e); }
 299   },
 300   assertNull: function(obj) {
 301     var message = arguments[1] || 'assertNull'
 302     try { (obj==null) ? this.pass() :
 303       this.fail(message + ': got "' + Test.Unit.inspect(obj) + '"'); }
 304     catch(e) { this.error(e); }
 305   },
 306   assertHidden: function(element) {
 307     var message = arguments[1] || 'assertHidden';
 308     this.assertEqual("none", element.style.display, message);
 309   },
 310   assertNotNull: function(object) {
 311     var message = arguments[1] || 'assertNotNull';
 312     this.assert(object != null, message);
 313   },
 314   assertInstanceOf: function(expected, actual) {
 315     var message = arguments[2] || 'assertInstanceOf';
 316     try {
 317       (actual instanceof expected) ? this.pass() :
 318       this.fail(message + ": object was not an instance of the expected type"); }
 319     catch(e) { this.error(e); }
 320   },
 321   assertNotInstanceOf: function(expected, actual) {
 322     var message = arguments[2] || 'assertNotInstanceOf';
 323     try {
 324       !(actual instanceof expected) ? this.pass() :
 325       this.fail(message + ": object was an instance of the not expected type"); }
 326     catch(e) { this.error(e); }
 327   },
 328   _isVisible: function(element) {
 329     element = $(element);
 330     if(!element.parentNode) return true;
 331     this.assertNotNull(element);
 332     if(element.style && Element.getStyle(element, 'display') == 'none')
 333       return false;
 334
 335     return this._isVisible(element.parentNode);
 336   },
 337   assertNotVisible: function(element) {
 338     this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
 339   },
 340   assertVisible: function(element) {
 341     this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
 342   },
 343   benchmark: function(operation, iterations) {
 344     var startAt = new Date();
 345     (iterations || 1).times(operation);
 346     var timeTaken = ((new Date())-startAt);
 347     this.info((arguments[2] || 'Operation') + ' finished ' +
 348        iterations + ' iterations in ' + (timeTaken/1000)+'s' );
 349     return timeTaken;
 350   }
 351 }
 352
 353 Test.Unit.Testcase = Class.create();
 354 Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.prototype), {
 355   initialize: function(name, test, setup, teardown) {
 356     Test.Unit.Assertions.prototype.initialize.bind(this)();
 357     this.name           = name;
 358     this.test           = test || function() {};
 359     this.setup          = setup || function() {};
 360     this.teardown       = teardown || function() {};
 361     this.isWaiting      = false;
 362     this.timeToWait     = 1000;
 363   },
 364   wait: function(time, nextPart) {
 365     this.isWaiting = true;
 366     this.test = nextPart;
 367     this.timeToWait = time;
 368   },
 369   run: function() {
 370     try {
 371       try {
 372         if (!this.isWaiting) this.setup.bind(this)();
 373         this.isWaiting = false;
 374         this.test.bind(this)();
 375       } finally {
 376         if(!this.isWaiting) {
 377           this.teardown.bind(this)();
 378         }
 379       }
 380     }
 381     catch(e) { this.error(e); }
 382   }
 383 });