root/afridex/plugins/Flutter/js/scriptaculous/unittest.js

Revision 21, 19.7 kB (checked in by admin, 18 years ago)
Line 
1// script.aculo.us unittest.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008
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
11Event.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
47Event.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
64Event.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
70var Test = {}
71Test.Unit = {};
72
73// security exception workaround
74Test.Unit.inspect = Object.inspect;
75
76Test.Unit.Logger = Class.create();
77Test.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
138Test.Unit.Runner = Class.create();
139Test.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
251Test.Unit.Assertions = Class.create();
252Test.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
466Test.Unit.Testcase = Class.create();
467Object.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
511Test.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
544Test.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};
Note: See TracBrowser for help on using the browser.