PageRenderTime 54ms CodeModel.GetById 6ms app.highlight 42ms RepoModel.GetById 2ms app.codeStats 0ms

/testing/selenium-core/lib/scriptaculous/unittest.js

http://datanucleus-appengine.googlecode.com/
JavaScript | 383 lines | 335 code | 15 blank | 33 comment | 63 complexity | 19e5e5117633a8bc41724d0bc67e4162 MD5 | raw file
  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
 26Event.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
 58Event.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
 75Event.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
 81var Test = {}
 82Test.Unit = {};
 83
 84// security exception workaround
 85Test.Unit.inspect = Object.inspect;
 86
 87Test.Unit.Logger = Class.create();
 88Test.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
137Test.Unit.Runner = Class.create();
138Test.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
239Test.Unit.Assertions = Class.create();
240Test.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
353Test.Unit.Testcase = Class.create();
354Object.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});