[44] | 1 | // script.aculo.us unittest.js v1.8.0, Tue Nov 06 15:01:40 +0300 2007
|
---|
| 2 |
|
---|
| 3 | // Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
|
---|
| 4 | // (c) 2005-2007 Jon Tirsen (http://www.tirsen.com)
|
---|
| 5 | // (c) 2005-2007 Michael Schuerig (http://www.schuerig.de/michael/)
|
---|
| 6 | //
|
---|
| 7 | // script.aculo.us is freely distributable under the terms of an MIT-style license.
|
---|
| 8 | // For details, see the script.aculo.us web site: http://script.aculo.us/
|
---|
| 9 |
|
---|
| 10 | // experimental, Firefox-only
|
---|
| 11 | Event.simulateMouse = function(element, eventName) {
|
---|
| 12 | var options = Object.extend({
|
---|
| 13 | pointerX: 0,
|
---|
| 14 | pointerY: 0,
|
---|
| 15 | buttons: 0,
|
---|
| 16 | ctrlKey: false,
|
---|
| 17 | altKey: false,
|
---|
| 18 | shiftKey: false,
|
---|
| 19 | metaKey: false
|
---|
| 20 | }, arguments[2] || {});
|
---|
| 21 | var oEvent = document.createEvent("MouseEvents");
|
---|
| 22 | oEvent.initMouseEvent(eventName, true, true, document.defaultView,
|
---|
| 23 | options.buttons, options.pointerX, options.pointerY, options.pointerX, options.pointerY,
|
---|
| 24 | options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, $(element));
|
---|
| 25 |
|
---|
| 26 | if(this.mark) Element.remove(this.mark);
|
---|
| 27 | this.mark = document.createElement('div');
|
---|
| 28 | this.mark.appendChild(document.createTextNode(" "));
|
---|
| 29 | document.body.appendChild(this.mark);
|
---|
| 30 | this.mark.style.position = 'absolute';
|
---|
| 31 | this.mark.style.top = options.pointerY + "px";
|
---|
| 32 | this.mark.style.left = options.pointerX + "px";
|
---|
| 33 | this.mark.style.width = "5px";
|
---|
| 34 | this.mark.style.height = "5px;";
|
---|
| 35 | this.mark.style.borderTop = "1px solid red;"
|
---|
| 36 | this.mark.style.borderLeft = "1px solid red;"
|
---|
| 37 |
|
---|
| 38 | if(this.step)
|
---|
| 39 | alert('['+new Date().getTime().toString()+'] '+eventName+'/'+Test.Unit.inspect(options));
|
---|
| 40 |
|
---|
| 41 | $(element).dispatchEvent(oEvent);
|
---|
| 42 | };
|
---|
| 43 |
|
---|
| 44 | // 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.
|
---|
| 45 | // You need to downgrade to 1.0.4 for now to get this working
|
---|
| 46 | // See https://bugzilla.mozilla.org/show_bug.cgi?id=289940 for the fix that fixed too much
|
---|
| 47 | Event.simulateKey = function(element, eventName) {
|
---|
| 48 | var options = Object.extend({
|
---|
| 49 | ctrlKey: false,
|
---|
| 50 | altKey: false,
|
---|
| 51 | shiftKey: false,
|
---|
| 52 | metaKey: false,
|
---|
| 53 | keyCode: 0,
|
---|
| 54 | charCode: 0
|
---|
| 55 | }, arguments[2] || {});
|
---|
| 56 |
|
---|
| 57 | var oEvent = document.createEvent("KeyEvents");
|
---|
| 58 | oEvent.initKeyEvent(eventName, true, true, window,
|
---|
| 59 | options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
|
---|
| 60 | options.keyCode, options.charCode );
|
---|
| 61 | $(element).dispatchEvent(oEvent);
|
---|
| 62 | };
|
---|
| 63 |
|
---|
| 64 | Event.simulateKeys = function(element, command) {
|
---|
| 65 | for(var i=0; i<command.length; i++) {
|
---|
| 66 | Event.simulateKey(element,'keypress',{charCode:command.charCodeAt(i)});
|
---|
| 67 | }
|
---|
| 68 | };
|
---|
| 69 |
|
---|
| 70 | var Test = {}
|
---|
| 71 | Test.Unit = {};
|
---|
| 72 |
|
---|
| 73 | // security exception workaround
|
---|
| 74 | Test.Unit.inspect = Object.inspect;
|
---|
| 75 |
|
---|
| 76 | Test.Unit.Logger = Class.create();
|
---|
| 77 | Test.Unit.Logger.prototype = {
|
---|
| 78 | initialize: function(log) {
|
---|
| 79 | this.log = $(log);
|
---|
| 80 | if (this.log) {
|
---|
| 81 | this._createLogTable();
|
---|
| 82 | }
|
---|
| 83 | },
|
---|
| 84 | start: function(testName) {
|
---|
| 85 | if (!this.log) return;
|
---|
| 86 | this.testName = testName;
|
---|
| 87 | this.lastLogLine = document.createElement('tr');
|
---|
| 88 | this.statusCell = document.createElement('td');
|
---|
| 89 | this.nameCell = document.createElement('td');
|
---|
| 90 | this.nameCell.className = "nameCell";
|
---|
| 91 | this.nameCell.appendChild(document.createTextNode(testName));
|
---|
| 92 | this.messageCell = document.createElement('td');
|
---|
| 93 | this.lastLogLine.appendChild(this.statusCell);
|
---|
| 94 | this.lastLogLine.appendChild(this.nameCell);
|
---|
| 95 | this.lastLogLine.appendChild(this.messageCell);
|
---|
| 96 | this.loglines.appendChild(this.lastLogLine);
|
---|
| 97 | },
|
---|
| 98 | finish: function(status, summary) {
|
---|
| 99 | if (!this.log) return;
|
---|
| 100 | this.lastLogLine.className = status;
|
---|
| 101 | this.statusCell.innerHTML = status;
|
---|
| 102 | this.messageCell.innerHTML = this._toHTML(summary);
|
---|
| 103 | this.addLinksToResults();
|
---|
| 104 | },
|
---|
| 105 | message: function(message) {
|
---|
| 106 | if (!this.log) return;
|
---|
| 107 | this.messageCell.innerHTML = this._toHTML(message);
|
---|
| 108 | },
|
---|
| 109 | summary: function(summary) {
|
---|
| 110 | if (!this.log) return;
|
---|
| 111 | this.logsummary.innerHTML = this._toHTML(summary);
|
---|
| 112 | },
|
---|
| 113 | _createLogTable: function() {
|
---|
| 114 | this.log.innerHTML =
|
---|
| 115 | '<div id="logsummary"></div>' +
|
---|
| 116 | '<table id="logtable">' +
|
---|
| 117 | '<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +
|
---|
| 118 | '<tbody id="loglines"></tbody>' +
|
---|
| 119 | '</table>';
|
---|
| 120 | this.logsummary = $('logsummary')
|
---|
| 121 | this.loglines = $('loglines');
|
---|
| 122 | },
|
---|
| 123 | _toHTML: function(txt) {
|
---|
| 124 | return txt.escapeHTML().replace(/\n/g,"<br/>");
|
---|
| 125 | },
|
---|
| 126 | addLinksToResults: function(){
|
---|
| 127 | $$("tr.failed .nameCell").each( function(td){ // todo: limit to children of this.log
|
---|
| 128 | td.title = "Run only this test"
|
---|
| 129 | Event.observe(td, 'click', function(){ window.location.search = "?tests=" + td.innerHTML;});
|
---|
| 130 | });
|
---|
| 131 | $$("tr.passed .nameCell").each( function(td){ // todo: limit to children of this.log
|
---|
| 132 | td.title = "Run all tests"
|
---|
| 133 | Event.observe(td, 'click', function(){ window.location.search = "";});
|
---|
| 134 | });
|
---|
| 135 | }
|
---|
| 136 | }
|
---|
| 137 |
|
---|
| 138 | Test.Unit.Runner = Class.create();
|
---|
| 139 | Test.Unit.Runner.prototype = {
|
---|
| 140 | initialize: function(testcases) {
|
---|
| 141 | this.options = Object.extend({
|
---|
| 142 | testLog: 'testlog'
|
---|
| 143 | }, arguments[1] || {});
|
---|
| 144 | this.options.resultsURL = this.parseResultsURLQueryParameter();
|
---|
| 145 | this.options.tests = this.parseTestsQueryParameter();
|
---|
| 146 | if (this.options.testLog) {
|
---|
| 147 | this.options.testLog = $(this.options.testLog) || null;
|
---|
| 148 | }
|
---|
| 149 | if(this.options.tests) {
|
---|
| 150 | this.tests = [];
|
---|
| 151 | for(var i = 0; i < this.options.tests.length; i++) {
|
---|
| 152 | if(/^test/.test(this.options.tests[i])) {
|
---|
| 153 | this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));
|
---|
| 154 | }
|
---|
| 155 | }
|
---|
| 156 | } else {
|
---|
| 157 | if (this.options.test) {
|
---|
| 158 | this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];
|
---|
| 159 | } else {
|
---|
| 160 | this.tests = [];
|
---|
| 161 | for(var testcase in testcases) {
|
---|
| 162 | if(/^test/.test(testcase)) {
|
---|
| 163 | this.tests.push(
|
---|
| 164 | new Test.Unit.Testcase(
|
---|
| 165 | this.options.context ? ' -> ' + this.options.titles[testcase] : testcase,
|
---|
| 166 | testcases[testcase], testcases["setup"], testcases["teardown"]
|
---|
| 167 | ));
|
---|
| 168 | }
|
---|
| 169 | }
|
---|
| 170 | }
|
---|
| 171 | }
|
---|
| 172 | this.currentTest = 0;
|
---|
| 173 | this.logger = new Test.Unit.Logger(this.options.testLog);
|
---|
| 174 | setTimeout(this.runTests.bind(this), 1000);
|
---|
| 175 | },
|
---|
| 176 | parseResultsURLQueryParameter: function() {
|
---|
| 177 | return window.location.search.parseQuery()["resultsURL"];
|
---|
| 178 | },
|
---|
| 179 | parseTestsQueryParameter: function(){
|
---|
| 180 | if (window.location.search.parseQuery()["tests"]){
|
---|
| 181 | return window.location.search.parseQuery()["tests"].split(',');
|
---|
| 182 | };
|
---|
| 183 | },
|
---|
| 184 | // Returns:
|
---|
| 185 | // "ERROR" if there was an error,
|
---|
| 186 | // "FAILURE" if there was a failure, or
|
---|
| 187 | // "SUCCESS" if there was neither
|
---|
| 188 | getResult: function() {
|
---|
| 189 | var hasFailure = false;
|
---|
| 190 | for(var i=0;i<this.tests.length;i++) {
|
---|
| 191 | if (this.tests[i].errors > 0) {
|
---|
| 192 | return "ERROR";
|
---|
| 193 | }
|
---|
| 194 | if (this.tests[i].failures > 0) {
|
---|
| 195 | hasFailure = true;
|
---|
| 196 | }
|
---|
| 197 | }
|
---|
| 198 | if (hasFailure) {
|
---|
| 199 | return "FAILURE";
|
---|
| 200 | } else {
|
---|
| 201 | return "SUCCESS";
|
---|
| 202 | }
|
---|
| 203 | },
|
---|
| 204 | postResults: function() {
|
---|
| 205 | if (this.options.resultsURL) {
|
---|
| 206 | new Ajax.Request(this.options.resultsURL,
|
---|
| 207 | { method: 'get', parameters: 'result=' + this.getResult(), asynchronous: false });
|
---|
| 208 | }
|
---|
| 209 | },
|
---|
| 210 | runTests: function() {
|
---|
| 211 | var test = this.tests[this.currentTest];
|
---|
| 212 | if (!test) {
|
---|
| 213 | // finished!
|
---|
| 214 | this.postResults();
|
---|
| 215 | this.logger.summary(this.summary());
|
---|
| 216 | return;
|
---|
| 217 | }
|
---|
| 218 | if(!test.isWaiting) {
|
---|
| 219 | this.logger.start(test.name);
|
---|
| 220 | }
|
---|
| 221 | test.run();
|
---|
| 222 | if(test.isWaiting) {
|
---|
| 223 | this.logger.message("Waiting for " + test.timeToWait + "ms");
|
---|
| 224 | setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
|
---|
| 225 | } else {
|
---|
| 226 | this.logger.finish(test.status(), test.summary());
|
---|
| 227 | this.currentTest++;
|
---|
| 228 | // tail recursive, hopefully the browser will skip the stackframe
|
---|
| 229 | this.runTests();
|
---|
| 230 | }
|
---|
| 231 | },
|
---|
| 232 | summary: function() {
|
---|
| 233 | var assertions = 0;
|
---|
| 234 | var failures = 0;
|
---|
| 235 | var errors = 0;
|
---|
| 236 | var messages = [];
|
---|
| 237 | for(var i=0;i<this.tests.length;i++) {
|
---|
| 238 | assertions += this.tests[i].assertions;
|
---|
| 239 | failures += this.tests[i].failures;
|
---|
| 240 | errors += this.tests[i].errors;
|
---|
| 241 | }
|
---|
| 242 | return (
|
---|
| 243 | (this.options.context ? this.options.context + ': ': '') +
|
---|
| 244 | this.tests.length + " tests, " +
|
---|
| 245 | assertions + " assertions, " +
|
---|
| 246 | failures + " failures, " +
|
---|
| 247 | errors + " errors");
|
---|
| 248 | }
|
---|
| 249 | }
|
---|
| 250 |
|
---|
| 251 | Test.Unit.Assertions = Class.create();
|
---|
| 252 | Test.Unit.Assertions.prototype = {
|
---|
| 253 | initialize: function() {
|
---|
| 254 | this.assertions = 0;
|
---|
| 255 | this.failures = 0;
|
---|
| 256 | this.errors = 0;
|
---|
| 257 | this.messages = [];
|
---|
| 258 | },
|
---|
| 259 | summary: function() {
|
---|
| 260 | return (
|
---|
| 261 | this.assertions + " assertions, " +
|
---|
| 262 | this.failures + " failures, " +
|
---|
| 263 | this.errors + " errors" + "\n" +
|
---|
| 264 | this.messages.join("\n"));
|
---|
| 265 | },
|
---|
| 266 | pass: function() {
|
---|
| 267 | this.assertions++;
|
---|
| 268 | },
|
---|
| 269 | fail: function(message) {
|
---|
| 270 | this.failures++;
|
---|
| 271 | this.messages.push("Failure: " + message);
|
---|
| 272 | },
|
---|
| 273 | info: function(message) {
|
---|
| 274 | this.messages.push("Info: " + message);
|
---|
| 275 | },
|
---|
| 276 | error: function(error) {
|
---|
| 277 | this.errors++;
|
---|
| 278 | this.messages.push(error.name + ": "+ error.message + "(" + Test.Unit.inspect(error) +")");
|
---|
| 279 | },
|
---|
| 280 | status: function() {
|
---|
| 281 | if (this.failures > 0) return 'failed';
|
---|
| 282 | if (this.errors > 0) return 'error';
|
---|
| 283 | return 'passed';
|
---|
| 284 | },
|
---|
| 285 | assert: function(expression) {
|
---|
| 286 | var message = arguments[1] || 'assert: got "' + Test.Unit.inspect(expression) + '"';
|
---|
| 287 | try { expression ? this.pass() :
|
---|
| 288 | this.fail(message); }
|
---|
| 289 | catch(e) { this.error(e); }
|
---|
| 290 | },
|
---|
| 291 | assertEqual: function(expected, actual) {
|
---|
| 292 | var message = arguments[2] || "assertEqual";
|
---|
| 293 | try { (expected == actual) ? this.pass() :
|
---|
| 294 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 295 | '", actual "' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 296 | catch(e) { this.error(e); }
|
---|
| 297 | },
|
---|
| 298 | assertInspect: function(expected, actual) {
|
---|
| 299 | var message = arguments[2] || "assertInspect";
|
---|
| 300 | try { (expected == actual.inspect()) ? this.pass() :
|
---|
| 301 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 302 | '", actual "' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 303 | catch(e) { this.error(e); }
|
---|
| 304 | },
|
---|
| 305 | assertEnumEqual: function(expected, actual) {
|
---|
| 306 | var message = arguments[2] || "assertEnumEqual";
|
---|
| 307 | try { $A(expected).length == $A(actual).length &&
|
---|
| 308 | expected.zip(actual).all(function(pair) { return pair[0] == pair[1] }) ?
|
---|
| 309 | this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) +
|
---|
| 310 | ', actual ' + Test.Unit.inspect(actual)); }
|
---|
| 311 | catch(e) { this.error(e); }
|
---|
| 312 | },
|
---|
| 313 | assertNotEqual: function(expected, actual) {
|
---|
| 314 | var message = arguments[2] || "assertNotEqual";
|
---|
| 315 | try { (expected != actual) ? this.pass() :
|
---|
| 316 | this.fail(message + ': got "' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 317 | catch(e) { this.error(e); }
|
---|
| 318 | },
|
---|
| 319 | assertIdentical: function(expected, actual) {
|
---|
| 320 | var message = arguments[2] || "assertIdentical";
|
---|
| 321 | try { (expected === actual) ? this.pass() :
|
---|
| 322 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 323 | '", actual "' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 324 | catch(e) { this.error(e); }
|
---|
| 325 | },
|
---|
| 326 | assertNotIdentical: function(expected, actual) {
|
---|
| 327 | var message = arguments[2] || "assertNotIdentical";
|
---|
| 328 | try { !(expected === actual) ? this.pass() :
|
---|
| 329 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 330 | '", actual "' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 331 | catch(e) { this.error(e); }
|
---|
| 332 | },
|
---|
| 333 | assertNull: function(obj) {
|
---|
| 334 | var message = arguments[1] || 'assertNull'
|
---|
| 335 | try { (obj==null) ? this.pass() :
|
---|
| 336 | this.fail(message + ': got "' + Test.Unit.inspect(obj) + '"'); }
|
---|
| 337 | catch(e) { this.error(e); }
|
---|
| 338 | },
|
---|
| 339 | assertMatch: function(expected, actual) {
|
---|
| 340 | var message = arguments[2] || 'assertMatch';
|
---|
| 341 | var regex = new RegExp(expected);
|
---|
| 342 | try { (regex.exec(actual)) ? this.pass() :
|
---|
| 343 | this.fail(message + ' : regex: "' + Test.Unit.inspect(expected) + ' did not match: ' + Test.Unit.inspect(actual) + '"'); }
|
---|
| 344 | catch(e) { this.error(e); }
|
---|
| 345 | },
|
---|
| 346 | assertHidden: function(element) {
|
---|
| 347 | var message = arguments[1] || 'assertHidden';
|
---|
| 348 | this.assertEqual("none", element.style.display, message);
|
---|
| 349 | },
|
---|
| 350 | assertNotNull: function(object) {
|
---|
| 351 | var message = arguments[1] || 'assertNotNull';
|
---|
| 352 | this.assert(object != null, message);
|
---|
| 353 | },
|
---|
| 354 | assertType: function(expected, actual) {
|
---|
| 355 | var message = arguments[2] || 'assertType';
|
---|
| 356 | try {
|
---|
| 357 | (actual.constructor == expected) ? this.pass() :
|
---|
| 358 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 359 | '", actual "' + (actual.constructor) + '"'); }
|
---|
| 360 | catch(e) { this.error(e); }
|
---|
| 361 | },
|
---|
| 362 | assertNotOfType: function(expected, actual) {
|
---|
| 363 | var message = arguments[2] || 'assertNotOfType';
|
---|
| 364 | try {
|
---|
| 365 | (actual.constructor != expected) ? this.pass() :
|
---|
| 366 | this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
|
---|
| 367 | '", actual "' + (actual.constructor) + '"'); }
|
---|
| 368 | catch(e) { this.error(e); }
|
---|
| 369 | },
|
---|
| 370 | assertInstanceOf: function(expected, actual) {
|
---|
| 371 | var message = arguments[2] || 'assertInstanceOf';
|
---|
| 372 | try {
|
---|
| 373 | (actual instanceof expected) ? this.pass() :
|
---|
| 374 | this.fail(message + ": object was not an instance of the expected type"); }
|
---|
| 375 | catch(e) { this.error(e); }
|
---|
| 376 | },
|
---|
| 377 | assertNotInstanceOf: function(expected, actual) {
|
---|
| 378 | var message = arguments[2] || 'assertNotInstanceOf';
|
---|
| 379 | try {
|
---|
| 380 | !(actual instanceof expected) ? this.pass() :
|
---|
| 381 | this.fail(message + ": object was an instance of the not expected type"); }
|
---|
| 382 | catch(e) { this.error(e); }
|
---|
| 383 | },
|
---|
| 384 | assertRespondsTo: function(method, obj) {
|
---|
| 385 | var message = arguments[2] || 'assertRespondsTo';
|
---|
| 386 | try {
|
---|
| 387 | (obj[method] && typeof obj[method] == 'function') ? this.pass() :
|
---|
| 388 | this.fail(message + ": object doesn't respond to [" + method + "]"); }
|
---|
| 389 | catch(e) { this.error(e); }
|
---|
| 390 | },
|
---|
| 391 | assertReturnsTrue: function(method, obj) {
|
---|
| 392 | var message = arguments[2] || 'assertReturnsTrue';
|
---|
| 393 | try {
|
---|
| 394 | var m = obj[method];
|
---|
| 395 | if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
|
---|
| 396 | m() ? this.pass() :
|
---|
| 397 | this.fail(message + ": method returned false"); }
|
---|
| 398 | catch(e) { this.error(e); }
|
---|
| 399 | },
|
---|
| 400 | assertReturnsFalse: function(method, obj) {
|
---|
| 401 | var message = arguments[2] || 'assertReturnsFalse';
|
---|
| 402 | try {
|
---|
| 403 | var m = obj[method];
|
---|
| 404 | if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
|
---|
| 405 | !m() ? this.pass() :
|
---|
| 406 | this.fail(message + ": method returned true"); }
|
---|
| 407 | catch(e) { this.error(e); }
|
---|
| 408 | },
|
---|
| 409 | assertRaise: function(exceptionName, method) {
|
---|
| 410 | var message = arguments[2] || 'assertRaise';
|
---|
| 411 | try {
|
---|
| 412 | method();
|
---|
| 413 | this.fail(message + ": exception expected but none was raised"); }
|
---|
| 414 | catch(e) {
|
---|
| 415 | ((exceptionName == null) || (e.name==exceptionName)) ? this.pass() : this.error(e);
|
---|
| 416 | }
|
---|
| 417 | },
|
---|
| 418 | assertElementsMatch: function() {
|
---|
| 419 | var expressions = $A(arguments), elements = $A(expressions.shift());
|
---|
| 420 | if (elements.length != expressions.length) {
|
---|
| 421 | this.fail('assertElementsMatch: size mismatch: ' + elements.length + ' elements, ' + expressions.length + ' expressions');
|
---|
| 422 | return false;
|
---|
| 423 | }
|
---|
| 424 | elements.zip(expressions).all(function(pair, index) {
|
---|
| 425 | var element = $(pair.first()), expression = pair.last();
|
---|
| 426 | if (element.match(expression)) return true;
|
---|
| 427 | this.fail('assertElementsMatch: (in index ' + index + ') expected ' + expression.inspect() + ' but got ' + element.inspect());
|
---|
| 428 | }.bind(this)) && this.pass();
|
---|
| 429 | },
|
---|
| 430 | assertElementMatches: function(element, expression) {
|
---|
| 431 | this.assertElementsMatch([element], expression);
|
---|
| 432 | },
|
---|
| 433 | benchmark: function(operation, iterations) {
|
---|
| 434 | var startAt = new Date();
|
---|
| 435 | (iterations || 1).times(operation);
|
---|
| 436 | var timeTaken = ((new Date())-startAt);
|
---|
| 437 | this.info((arguments[2] || 'Operation') + ' finished ' +
|
---|
| 438 | iterations + ' iterations in ' + (timeTaken/1000)+'s' );
|
---|
| 439 | return timeTaken;
|
---|
| 440 | },
|
---|
| 441 | _isVisible: function(element) {
|
---|
| 442 | element = $(element);
|
---|
| 443 | if(!element.parentNode) return true;
|
---|
| 444 | this.assertNotNull(element);
|
---|
| 445 | if(element.style && Element.getStyle(element, 'display') == 'none')
|
---|
| 446 | return false;
|
---|
| 447 |
|
---|
| 448 | return this._isVisible(element.parentNode);
|
---|
| 449 | },
|
---|
| 450 | assertNotVisible: function(element) {
|
---|
| 451 | this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
|
---|
| 452 | },
|
---|
| 453 | assertVisible: function(element) {
|
---|
| 454 | this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
|
---|
| 455 | },
|
---|
| 456 | benchmark: function(operation, iterations) {
|
---|
| 457 | var startAt = new Date();
|
---|
| 458 | (iterations || 1).times(operation);
|
---|
| 459 | var timeTaken = ((new Date())-startAt);
|
---|
| 460 | this.info((arguments[2] || 'Operation') + ' finished ' +
|
---|
| 461 | iterations + ' iterations in ' + (timeTaken/1000)+'s' );
|
---|
| 462 | return timeTaken;
|
---|
| 463 | }
|
---|
| 464 | }
|
---|
| 465 |
|
---|
| 466 | Test.Unit.Testcase = Class.create();
|
---|
| 467 | Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.prototype), {
|
---|
| 468 | initialize: function(name, test, setup, teardown) {
|
---|
| 469 | Test.Unit.Assertions.prototype.initialize.bind(this)();
|
---|
| 470 | this.name = name;
|
---|
| 471 |
|
---|
| 472 | if(typeof test == 'string') {
|
---|
| 473 | test = test.gsub(/(\.should[^\(]+\()/,'#{0}this,');
|
---|
| 474 | test = test.gsub(/(\.should[^\(]+)\(this,\)/,'#{1}(this)');
|
---|
| 475 | this.test = function() {
|
---|
| 476 | eval('with(this){'+test+'}');
|
---|
| 477 | }
|
---|
| 478 | } else {
|
---|
| 479 | this.test = test || function() {};
|
---|
| 480 | }
|
---|
| 481 |
|
---|
| 482 | this.setup = setup || function() {};
|
---|
| 483 | this.teardown = teardown || function() {};
|
---|
| 484 | this.isWaiting = false;
|
---|
| 485 | this.timeToWait = 1000;
|
---|
| 486 | },
|
---|
| 487 | wait: function(time, nextPart) {
|
---|
| 488 | this.isWaiting = true;
|
---|
| 489 | this.test = nextPart;
|
---|
| 490 | this.timeToWait = time;
|
---|
| 491 | },
|
---|
| 492 | run: function() {
|
---|
| 493 | try {
|
---|
| 494 | try {
|
---|
| 495 | if (!this.isWaiting) this.setup.bind(this)();
|
---|
| 496 | this.isWaiting = false;
|
---|
| 497 | this.test.bind(this)();
|
---|
| 498 | } finally {
|
---|
| 499 | if(!this.isWaiting) {
|
---|
| 500 | this.teardown.bind(this)();
|
---|
| 501 | }
|
---|
| 502 | }
|
---|
| 503 | }
|
---|
| 504 | catch(e) { this.error(e); }
|
---|
| 505 | }
|
---|
| 506 | });
|
---|
| 507 |
|
---|
| 508 | // *EXPERIMENTAL* BDD-style testing to please non-technical folk
|
---|
| 509 | // This draws many ideas from RSpec http://rspec.rubyforge.org/
|
---|
| 510 |
|
---|
| 511 | Test.setupBDDExtensionMethods = function(){
|
---|
| 512 | var METHODMAP = {
|
---|
| 513 | shouldEqual: 'assertEqual',
|
---|
| 514 | shouldNotEqual: 'assertNotEqual',
|
---|
| 515 | shouldEqualEnum: 'assertEnumEqual',
|
---|
| 516 | shouldBeA: 'assertType',
|
---|
| 517 | shouldNotBeA: 'assertNotOfType',
|
---|
| 518 | shouldBeAn: 'assertType',
|
---|
| 519 | shouldNotBeAn: 'assertNotOfType',
|
---|
| 520 | shouldBeNull: 'assertNull',
|
---|
| 521 | shouldNotBeNull: 'assertNotNull',
|
---|
| 522 |
|
---|
| 523 | shouldBe: 'assertReturnsTrue',
|
---|
| 524 | shouldNotBe: 'assertReturnsFalse',
|
---|
| 525 | shouldRespondTo: 'assertRespondsTo'
|
---|
| 526 | };
|
---|
| 527 | var makeAssertion = function(assertion, args, object) {
|
---|
| 528 | this[assertion].apply(this,(args || []).concat([object]));
|
---|
| 529 | }
|
---|
| 530 |
|
---|
| 531 | Test.BDDMethods = {};
|
---|
| 532 | $H(METHODMAP).each(function(pair) {
|
---|
| 533 | Test.BDDMethods[pair.key] = function() {
|
---|
| 534 | var args = $A(arguments);
|
---|
| 535 | var scope = args.shift();
|
---|
| 536 | makeAssertion.apply(scope, [pair.value, args, this]); };
|
---|
| 537 | });
|
---|
| 538 |
|
---|
| 539 | [Array.prototype, String.prototype, Number.prototype, Boolean.prototype].each(
|
---|
| 540 | function(p){ Object.extend(p, Test.BDDMethods) }
|
---|
| 541 | );
|
---|
| 542 | }
|
---|
| 543 |
|
---|
| 544 | Test.context = function(name, spec, log){
|
---|
| 545 | Test.setupBDDExtensionMethods();
|
---|
| 546 |
|
---|
| 547 | var compiledSpec = {};
|
---|
| 548 | var titles = {};
|
---|
| 549 | for(specName in spec) {
|
---|
| 550 | switch(specName){
|
---|
| 551 | case "setup":
|
---|
| 552 | case "teardown":
|
---|
| 553 | compiledSpec[specName] = spec[specName];
|
---|
| 554 | break;
|
---|
| 555 | default:
|
---|
| 556 | var testName = 'test'+specName.gsub(/\s+/,'-').camelize();
|
---|
| 557 | var body = spec[specName].toString().split('\n').slice(1);
|
---|
| 558 | if(/^\{/.test(body[0])) body = body.slice(1);
|
---|
| 559 | body.pop();
|
---|
| 560 | body = body.map(function(statement){
|
---|
| 561 | return statement.strip()
|
---|
| 562 | });
|
---|
| 563 | compiledSpec[testName] = body.join('\n');
|
---|
| 564 | titles[testName] = specName;
|
---|
| 565 | }
|
---|
| 566 | }
|
---|
| 567 | new Test.Unit.Runner(compiledSpec, { titles: titles, testLog: log || 'testlog', context: name });
|
---|
| 568 | }; |
---|