root / web-presentation / trunk / eneraptor-web-presentation / web-app / js / prototype / unittest.js @ 92
History | View | Annotate | Download (19.7 KB)
1 |
// script.aculo.us unittest.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009
|
---|---|
2 |
|
3 |
// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
|
4 |
// (c) 2005-2009 Jon Tirsen (http://www.tirsen.com)
|
5 |
// (c) 2005-2009 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 |
}; |