// script.aculo.us unittest.js v1.7.0, Fri Jan 19 19:16:36 CET 2007



// Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)

//           (c) 2005, 2006 Jon Tirsen (http://www.tirsen.com)

//           (c) 2005, 2006 Michael Schuerig (http://www.schuerig.de/michael/)

//

// script.aculo.us is freely distributable under the terms of an MIT-style license.

// For details, see the script.aculo.us web site: http://script.aculo.us/



// experimental, Firefox-only

Event.simulateMouse = function(element, eventName) {

	var options = Object.extend({

		pointerX: 0,

		pointerY: 0,

		buttons:  0,

		ctrlKey:  false,

		altKey:   false,

		shiftKey: false,

		metaKey:  false

	}, arguments[2] || {});

	var oEvent = document.createEvent("MouseEvents");

	oEvent.initMouseEvent(eventName, true, true, document.defaultView,

	options.buttons, options.pointerX, options.pointerY, options.pointerX, options.pointerY,

	options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, $(element));



	if(this.mark) Element.remove(this.mark);

	this.mark = document.createElement('div');

	this.mark.appendChild(document.createTextNode(" "));

	document.body.appendChild(this.mark);

	this.mark.style.position = 'absolute';

	this.mark.style.top = options.pointerY + "px";

	this.mark.style.left = options.pointerX + "px";

	this.mark.style.width = "5px";

	this.mark.style.height = "5px;";

	this.mark.style.borderTop = "1px solid red;"

	this.mark.style.borderLeft = "1px solid red;"



	if(this.step)

	alert('['+new Date().getTime().toString()+'] '+eventName+'/'+Test.Unit.inspect(options));



	$(element).dispatchEvent(oEvent);

};



// 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.

// You need to downgrade to 1.0.4 for now to get this working

// See https://bugzilla.mozilla.org/show_bug.cgi?id=289940 for the fix that fixed too much

Event.simulateKey = function(element, eventName) {

	var options = Object.extend({

		ctrlKey: false,

		altKey: false,

		shiftKey: false,

		metaKey: false,

		keyCode: 0,

		charCode: 0

	}, arguments[2] || {});



	var oEvent = document.createEvent("KeyEvents");

	oEvent.initKeyEvent(eventName, true, true, window,

	options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,

	options.keyCode, options.charCode );

	$(element).dispatchEvent(oEvent);

};



Event.simulateKeys = function(element, command) {

	for(var i=0; i<command.length; i++) {

		Event.simulateKey(element,'keypress',{charCode:command.charCodeAt(i)});

	}

};



var Test = {}

Test.Unit = {};



// security exception workaround

Test.Unit.inspect = Object.inspect;



Test.Unit.Logger = Class.create();

Test.Unit.Logger.prototype = {

	initialize: function(log) {

		this.log = $(log);

		if (this.log) {

			this._createLogTable();

		}

	},

	start: function(testName) {

		if (!this.log) return;

		this.testName = testName;

		this.lastLogLine = document.createElement('tr');

		this.statusCell = document.createElement('td');

		this.nameCell = document.createElement('td');

		this.nameCell.className = "nameCell";

		this.nameCell.appendChild(document.createTextNode(testName));

		this.messageCell = document.createElement('td');

		this.lastLogLine.appendChild(this.statusCell);

		this.lastLogLine.appendChild(this.nameCell);

		this.lastLogLine.appendChild(this.messageCell);

		this.loglines.appendChild(this.lastLogLine);

	},

	finish: function(status, summary) {

		if (!this.log) return;

		this.lastLogLine.className = status;

		this.statusCell.innerHTML = status;

		this.messageCell.innerHTML = this._toHTML(summary);

		this.addLinksToResults();

	},

	message: function(message) {

		if (!this.log) return;

		this.messageCell.innerHTML = this._toHTML(message);

	},

	summary: function(summary) {

		if (!this.log) return;

		this.logsummary.innerHTML = this._toHTML(summary);

	},

	_createLogTable: function() {

		this.log.innerHTML =

		'<div id="logsummary"></div>' +

		'<table id="logtable">' +

		'<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +

		'<tbody id="loglines"></tbody>' +

		'</table>';

		this.logsummary = $('logsummary')

		this.loglines = $('loglines');

	},

	_toHTML: function(txt) {

		return txt.escapeHTML().replace(/\n/g,"<br/>");

	},

	addLinksToResults: function(){

		$$("tr.failed .nameCell").each( function(td){ // todo: limit to children of this.log

			td.title = "Run only this test"

			Event.observe(td, 'click', function(){ window.location.search = "?tests=" + td.innerHTML;});

		});

		$$("tr.passed .nameCell").each( function(td){ // todo: limit to children of this.log

			td.title = "Run all tests"

			Event.observe(td, 'click', function(){ window.location.search = "";});

		});

	}

}



Test.Unit.Runner = Class.create();

Test.Unit.Runner.prototype = {

	initialize: function(testcases) {

		this.options = Object.extend({

			testLog: 'testlog'

		}, arguments[1] || {});

		this.options.resultsURL = this.parseResultsURLQueryParameter();

		this.options.tests      = this.parseTestsQueryParameter();

		if (this.options.testLog) {

			this.options.testLog = $(this.options.testLog) || null;

		}

		if(this.options.tests) {

			this.tests = [];

			for(var i = 0; i < this.options.tests.length; i++) {

				if(/^test/.test(this.options.tests[i])) {

					this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));

				}

			}

		} else {

			if (this.options.test) {

				this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];

			} else {

				this.tests = [];

				for(var testcase in testcases) {

					if(/^test/.test(testcase)) {

						this.tests.push(

						new Test.Unit.Testcase(

						this.options.context ? ' -> ' + this.options.titles[testcase] : testcase,

						testcases[testcase], testcases["setup"], testcases["teardown"]

						));

					}

				}

			}

		}

		this.currentTest = 0;

		this.logger = new Test.Unit.Logger(this.options.testLog);

		setTimeout(this.runTests.bind(this), 1000);

	},

	parseResultsURLQueryParameter: function() {

		return window.location.search.parseQuery()["resultsURL"];

	},

	parseTestsQueryParameter: function(){

		if (window.location.search.parseQuery()["tests"]){

			return window.location.search.parseQuery()["tests"].split(',');

		};

	},

	// Returns:

	//  "ERROR" if there was an error,

	//  "FAILURE" if there was a failure, or

	//  "SUCCESS" if there was neither

	getResult: function() {

		var hasFailure = false;

		for(var i=0;i<this.tests.length;i++) {

			if (this.tests[i].errors > 0) {

				return "ERROR";

			}

			if (this.tests[i].failures > 0) {

				hasFailure = true;

			}

		}

		if (hasFailure) {

			return "FAILURE";

		} else {

			return "SUCCESS";

		}

	},

	postResults: function() {

		if (this.options.resultsURL) {

			new Ajax.Request(this.options.resultsURL,

			{ method: 'get', parameters: 'result=' + this.getResult(), asynchronous: false });

		}

	},

	runTests: function() {

		var test = this.tests[this.currentTest];

		if (!test) {

			// finished!

			this.postResults();

			this.logger.summary(this.summary());

			return;

		}

		if(!test.isWaiting) {

			this.logger.start(test.name);

		}

		test.run();

		if(test.isWaiting) {

			this.logger.message("Waiting for " + test.timeToWait + "ms");

			setTimeout(this.runTests.bind(this), test.timeToWait || 1000);

		} else {

			this.logger.finish(test.status(), test.summary());

			this.currentTest++;

			// tail recursive, hopefully the browser will skip the stackframe

			this.runTests();

		}

	},

	summary: function() {

		var assertions = 0;

		var failures = 0;

		var errors = 0;

		var messages = [];

		for(var i=0;i<this.tests.length;i++) {

			assertions +=   this.tests[i].assertions;

			failures   +=   this.tests[i].failures;

			errors     +=   this.tests[i].errors;

		}

		return (

		(this.options.context ? this.options.context + ': ': '') +

		this.tests.length + " tests, " +

		assertions + " assertions, " +

		failures   + " failures, " +

		errors     + " errors");

	}

}



Test.Unit.Assertions = Class.create();

Test.Unit.Assertions.prototype = {

	initialize: function() {

		this.assertions = 0;

		this.failures   = 0;

		this.errors     = 0;

		this.messages   = [];

	},

	summary: function() {

		return (

		this.assertions + " assertions, " +

		this.failures   + " failures, " +

		this.errors     + " errors" + "\n" +

		this.messages.join("\n"));

	},

	pass: function() {

		this.assertions++;

	},

	fail: function(message) {

		this.failures++;

		this.messages.push("Failure: " + message);

	},

	info: function(message) {

		this.messages.push("Info: " + message);

	},

	error: function(error) {

		this.errors++;

		this.messages.push(error.name + ": "+ error.message + "(" + Test.Unit.inspect(error) +")");

	},

	status: function() {

		if (this.failures > 0) return 'failed';

		if (this.errors > 0) return 'error';

		return 'passed';

	},

	assert: function(expression) {

		var message = arguments[1] || 'assert: got "' + Test.Unit.inspect(expression) + '"';

		try { expression ? this.pass() :

		this.fail(message); }

		catch(e) { this.error(e); }

	},

	assertEqual: function(expected, actual) {

		var message = arguments[2] || "assertEqual";

		try { (expected == actual) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertInspect: function(expected, actual) {

		var message = arguments[2] || "assertInspect";

		try { (expected == actual.inspect()) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertEnumEqual: function(expected, actual) {

		var message = arguments[2] || "assertEnumEqual";

		try { $A(expected).length == $A(actual).length &&

		expected.zip(actual).all(function(pair) { return pair[0] == pair[1] }) ?

		this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) +

		', actual ' + Test.Unit.inspect(actual)); }

		catch(e) { this.error(e); }

	},

	assertNotEqual: function(expected, actual) {

		var message = arguments[2] || "assertNotEqual";

		try { (expected != actual) ? this.pass() :

		this.fail(message + ': got "' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertIdentical: function(expected, actual) {

		var message = arguments[2] || "assertIdentical";

		try { (expected === actual) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertNotIdentical: function(expected, actual) {

		var message = arguments[2] || "assertNotIdentical";

		try { !(expected === actual) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertNull: function(obj) {

		var message = arguments[1] || 'assertNull'

		try { (obj==null) ? this.pass() :

		this.fail(message + ': got "' + Test.Unit.inspect(obj) + '"'); }

		catch(e) { this.error(e); }

	},

	assertMatch: function(expected, actual) {

		var message = arguments[2] || 'assertMatch';

		var regex = new RegExp(expected);

		try { (regex.exec(actual)) ? this.pass() :

		this.fail(message + ' : regex: "' +  Test.Unit.inspect(expected) + ' did not match: ' + Test.Unit.inspect(actual) + '"'); }

		catch(e) { this.error(e); }

	},

	assertHidden: function(element) {

		var message = arguments[1] || 'assertHidden';

		this.assertEqual("none", element.style.display, message);

	},

	assertNotNull: function(object) {

		var message = arguments[1] || 'assertNotNull';

		this.assert(object != null, message);

	},

	assertType: function(expected, actual) {

		var message = arguments[2] || 'assertType';

		try {

		(actual.constructor == expected) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + (actual.constructor) + '"'); }

		catch(e) { this.error(e); }

	},

	assertNotOfType: function(expected, actual) {

		var message = arguments[2] || 'assertNotOfType';

		try {

		(actual.constructor != expected) ? this.pass() :

		this.fail(message + ': expected "' + Test.Unit.inspect(expected) +

		'", actual "' + (actual.constructor) + '"'); }

		catch(e) { this.error(e); }

	},

	assertInstanceOf: function(expected, actual) {

		var message = arguments[2] || 'assertInstanceOf';

		try {

		(actual instanceof expected) ? this.pass() :

		this.fail(message + ": object was not an instance of the expected type"); }

		catch(e) { this.error(e); }

	},

	assertNotInstanceOf: function(expected, actual) {

		var message = arguments[2] || 'assertNotInstanceOf';

		try {

			!(actual instanceof expected) ? this.pass() :

			this.fail(message + ": object was an instance of the not expected type"); }

			catch(e) { this.error(e); }

	},

	assertRespondsTo: function(method, obj) {

		var message = arguments[2] || 'assertRespondsTo';

		try {

		(obj[method] && typeof obj[method] == 'function') ? this.pass() :

		this.fail(message + ": object doesn't respond to [" + method + "]"); }

		catch(e) { this.error(e); }

	},

	assertReturnsTrue: function(method, obj) {

		var message = arguments[2] || 'assertReturnsTrue';

		try {

			var m = obj[method];

			if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];

			m() ? this.pass() :

			this.fail(message + ": method returned false"); }

			catch(e) { this.error(e); }

	},

	assertReturnsFalse: function(method, obj) {

		var message = arguments[2] || 'assertReturnsFalse';

		try {

			var m = obj[method];

			if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];

			!m() ? this.pass() :

			this.fail(message + ": method returned true"); }

			catch(e) { this.error(e); }

	},

	assertRaise: function(exceptionName, method) {

		var message = arguments[2] || 'assertRaise';

		try {

			method();

			this.fail(message + ": exception expected but none was raised"); }

			catch(e) {

			((exceptionName == null) || (e.name==exceptionName)) ? this.pass() : this.error(e);

			}

	},

	assertElementsMatch: function() {

		var expressions = $A(arguments), elements = $A(expressions.shift());

		if (elements.length != expressions.length) {

			this.fail('assertElementsMatch: size mismatch: ' + elements.length + ' elements, ' + expressions.length + ' expressions');

			return false;

		}

		elements.zip(expressions).all(function(pair, index) {

			var element = $(pair.first()), expression = pair.last();

			if (element.match(expression)) return true;

			this.fail('assertElementsMatch: (in index ' + index + ') expected ' + expression.inspect() + ' but got ' + element.inspect());

		}.bind(this)) && this.pass();

	},

	assertElementMatches: function(element, expression) {

		this.assertElementsMatch([element], expression);

	},

	benchmark: function(operation, iterations) {

		var startAt = new Date();

		(iterations || 1).times(operation);

		var timeTaken = ((new Date())-startAt);

		this.info((arguments[2] || 'Operation') + ' finished ' +

		iterations + ' iterations in ' + (timeTaken/1000)+'s' );

		return timeTaken;

	},

	_isVisible: function(element) {

		element = $(element);

		if(!element.parentNode) return true;

		this.assertNotNull(element);

		if(element.style && Element.getStyle(element, 'display') == 'none')

		return false;



		return this._isVisible(element.parentNode);

	},

	assertNotVisible: function(element) {

		this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));

	},

	assertVisible: function(element) {

		this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));

	},

	benchmark: function(operation, iterations) {

		var startAt = new Date();

		(iterations || 1).times(operation);

		var timeTaken = ((new Date())-startAt);

		this.info((arguments[2] || 'Operation') + ' finished ' +

		iterations + ' iterations in ' + (timeTaken/1000)+'s' );

		return timeTaken;

	}

}



Test.Unit.Testcase = Class.create();

Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.prototype), {

	initialize: function(name, test, setup, teardown) {

		Test.Unit.Assertions.prototype.initialize.bind(this)();

		this.name           = name;



		if(typeof test == 'string') {

			test = test.gsub(/(\.should[^\(]+\()/,'#{0}this,');

			test = test.gsub(/(\.should[^\(]+)\(this,\)/,'#{1}(this)');

			this.test = function() {

				eval('with(this){'+test+'}');

			}

		} else {

			this.test = test || function() {};

		}



		this.setup          = setup || function() {};

		this.teardown       = teardown || function() {};

		this.isWaiting      = false;

		this.timeToWait     = 1000;

	},

	wait: function(time, nextPart) {

		this.isWaiting = true;

		this.test = nextPart;

		this.timeToWait = time;

	},

	run: function() {

		try {

			try {

				if (!this.isWaiting) this.setup.bind(this)();

				this.isWaiting = false;

				this.test.bind(this)();

			} finally {

				if(!this.isWaiting) {

					this.teardown.bind(this)();

				}

			}

		}

		catch(e) { this.error(e); }

	}

});



// *EXPERIMENTAL* BDD-style testing to please non-technical folk

// This draws many ideas from RSpec http://rspec.rubyforge.org/



Test.setupBDDExtensionMethods = function(){

	var METHODMAP = {

		shouldEqual:     'assertEqual',

		shouldNotEqual:  'assertNotEqual',

		shouldEqualEnum: 'assertEnumEqual',

		shouldBeA:       'assertType',

		shouldNotBeA:    'assertNotOfType',

		shouldBeAn:      'assertType',

		shouldNotBeAn:   'assertNotOfType',

		shouldBeNull:    'assertNull',

		shouldNotBeNull: 'assertNotNull',



		shouldBe:        'assertReturnsTrue',

		shouldNotBe:     'assertReturnsFalse',

		shouldRespondTo: 'assertRespondsTo'

	};

	Test.BDDMethods = {};

	for(m in METHODMAP) {

		Test.BDDMethods[m] = eval(

		'function(){'+

		'var args = $A(arguments);'+

		'var scope = args.shift();'+

		'scope.'+METHODMAP[m]+'.apply(scope,(args || []).concat([this])); }');

	}

	[Array.prototype, String.prototype, Number.prototype].each(

	function(p){ Object.extend(p, Test.BDDMethods) }

	);

}



Test.context = function(name, spec, log){

	Test.setupBDDExtensionMethods();



	var compiledSpec = {};

	var titles = {};

	for(specName in spec) {

		switch(specName){

			case "setup":

			case "teardown":

			compiledSpec[specName] = spec[specName];

			break;

			default:

			var testName = 'test'+specName.gsub(/\s+/,'-').camelize();

			var body = spec[specName].toString().split('\n').slice(1);

			if(/^\{/.test(body[0])) body = body.slice(1);

			body.pop();

			body = body.map(function(statement){

				return statement.strip()

			});

			compiledSpec[testName] = body.join('\n');

			titles[testName] = specName;

		}

	}

	new Test.Unit.Runner(compiledSpec, { titles: titles, testLog: log || 'testlog', context: name });

};