@@ -1,17 +1,21 @@ /* JSMock * * Usage: - * new Mock(Math, 'random', 1); => <mock object> - * Math.mock('random', 2, 3); => <Math object> - * Math.random(); => 3 - * Math.random(); => 2 - * Math.random(); => 1 - * Math.random(); => actual random + * new Mock(Math, 'random', 1);// => <mock object> + * Mock.init(); // You need to init to run mock on objects like below + * Math.mock('random', 2, 3);// => <Math object> + * Math.random();// => 3 + * Math.random();// => 2 + * Math.random();// => 1 + * Math.random();// => actual random * - * Math.mock('random', 1, 2); => <Math object> - * Mock.reset(); // to clear all mocks + * Math.mock('random', 1, 2);// => <Math object> + * Mock.reset();// // to clear all mocks * // or: Math.random.reset(); // to just clear the Math.random mock - * Math.random(); => actual random + * Math.random();// => actual random + * + * // use this to restore original Mock object (if you had one) + * Mock.noFootprint();// => Mock * * Copyright (c) 2008 Douglas Meyer * @@ -72,21 +76,21 @@ } this.mocks = []; }; + Mock.init = function(){ + window.mock = Object.prototype.mock = function(){ + var args=[ this ]; + for(var index=0, arg;arg=arguments[index];index++){ + args.push(arg); + } + var mock = Mock.apply(null, args); + return(this); + }; + }; Mock.noFootprint = function(){ Object.prototype.mock = object_mock; window.mock = window_mock; - if (arguments.length > 0) { - window.Mock = _Mock; - } + window.Mock = _Mock; return Mock; }; - window.mock = Object.prototype.mock = function(){ - var args=[ this ]; - for(var index=0, arg;arg=arguments[index];index++){ - args.push(arg); - } - var mock = Mock.apply(null, args); - return(this); - }; })(); src/mock.js @@ -1,38 +1,27 @@ -// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us) -// (c) 2005 Jon Tirsen (http://www.tirsen.com) -// (c) 2005 Michael Schuerig (http://www.schuerig.de/michael/) -// -// Permission is hereby granted, free of charge, to any person obtaining -// a copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to -// permit persons to whom the Software is furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// script.aculo.us unittest.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008 +// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us) +// (c) 2005-2007 Jon Tirsen (http://www.tirsen.com) +// (c) 2005-2007 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 + 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, - false, false, false, false, 0, $(element)); + options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, $(element)); if(this.mark) Element.remove(this.mark); this.mark = document.createElement('div'); @@ -98,6 +87,7 @@ Test.Unit.Logger.prototype = { 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); @@ -110,6 +100,7 @@ Test.Unit.Logger.prototype = { this.lastLogLine.className = status; this.statusCell.innerHTML = status; this.messageCell.innerHTML = this._toHTML(summary); + this.addLinksToResults(); }, message: function(message) { if (!this.log) return; @@ -131,6 +122,16 @@ Test.Unit.Logger.prototype = { }, _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 = "";}); + }); } } @@ -141,6 +142,7 @@ Test.Unit.Runner.prototype = { 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; } @@ -158,7 +160,11 @@ Test.Unit.Runner.prototype = { this.tests = []; for(var testcase in testcases) { if(/^test/.test(testcase)) { - this.tests.push(new Test.Unit.Testcase(testcase, testcases[testcase], testcases["setup"], testcases["teardown"])); + this.tests.push( + new Test.Unit.Testcase( + this.options.context ? ' -> ' + this.options.titles[testcase] : testcase, + testcases[testcase], testcases["setup"], testcases["teardown"] + )); } } } @@ -170,6 +176,11 @@ Test.Unit.Runner.prototype = { 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 @@ -229,6 +240,7 @@ Test.Unit.Runner.prototype = { errors += this.tests[i].errors; } return ( + (this.options.context ? this.options.context + ': ': '') + this.tests.length + " tests, " + assertions + " assertions, " + failures + " failures, " + @@ -283,6 +295,13 @@ Test.Unit.Assertions.prototype = { '", 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 && @@ -297,12 +316,33 @@ Test.Unit.Assertions.prototype = { 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); @@ -311,6 +351,22 @@ Test.Unit.Assertions.prototype = { 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 { @@ -325,6 +381,63 @@ Test.Unit.Assertions.prototype = { 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; @@ -355,7 +468,17 @@ Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.p initialize: function(name, test, setup, teardown) { Test.Unit.Assertions.prototype.initialize.bind(this)(); this.name = name; - this.test = test || function() {}; + + 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; @@ -381,3 +504,65 @@ Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.p 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' + }; + var makeAssertion = function(assertion, args, object) { + this[assertion].apply(this,(args || []).concat([object])); + } + + Test.BDDMethods = {}; + $H(METHODMAP).each(function(pair) { + Test.BDDMethods[pair.key] = function() { + var args = $A(arguments); + var scope = args.shift(); + makeAssertion.apply(scope, [pair.value, args, this]); }; + }); + + [Array.prototype, String.prototype, Number.prototype, Boolean.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 }); +}; \ No newline at end of file tests/lib/unittest.js @@ -26,69 +26,63 @@ <script type="text/javascript" language="javascript" charset="utf-8"> // <![CDATA[ + var originalMock = window.Mock; + new Test.Unit.Runner({ setup: function() { with(this) { + try{ originalMock.noFootprint(true); }catch(e){ window.status += 'noFootprint broke'+e+"|"; } + window.Mock = originalMock; initialRandom = Math.random; initialRound = Math.round; initialSetTimeout = window.setTimeout; }}, teardown: function() { with(this) { + try{ originalMock.reset(); }catch(e){ window.status += 'reset broke'+e+"|" } window.setTimeout = initialSetTimeout; Math.round = initialRound; Math.random = initialRandom; }}, - testObjectMock_MakesTheNextCallReturnWhatYouPassed: function() { with(this) { - Math.mock('random', 3); + testMockObject_MakesTheNextCallReturnWhatYouPassed: function() { with(this) { + new Mock(Math, 'random', 3); assertEqual(3, Math.random()); }}, - testObjectMock_RemovesMockAfterItIsCalled: function(){with(this){ - Math.mock('random', 3); + testMockObject_RemovesMockAfterItIsCalled: function(){with(this){ + new Mock(Math, 'random', 3); Math.random(); assertEqual(initialRandom, Math.random); }}, - testObjectMock_GetsExecutedLikeAStack: function(){with(this){ - Math.mock('random', 3); - Math.mock('random', 4); + testMockObject_GetsExecutedLikeAStack: function(){with(this){ + new Mock(Math, 'random', 3); + new Mock(Math, 'random', 4); assertEqual(4, Math.random()); assertEqual(3, Math.random()); }}, - testObjectMockWithMultipleArguments_GetsAddedLikeAStack: function(){with(this){ - Math.mock('random', 3, 4); + testMockObjectWithMultipleArguments_GetsAddedLikeAStack: function(){with(this){ + new Mock(Math, 'random', 3, 4); assertEqual(4, Math.random()); assertEqual(3, Math.random()); }}, - testObjectMocks_CanBeChained: function(){with(this){ - var initialRound = Math.round; - - Math.mock('random', 3).mock('round', 4); - - assertEqual(3, Math.random()); - assertEqual(4, Math.round()); - assertEqual(initialRandom, Math.random); - assertEqual(initialRound, Math.round); - }}, - - testObjectMock_WillCallFunctionIfFunctionPassed: function(){with(this){ - Math.mock('random', function(arg){ return(arg+1); }); + testMockObject_WillCallFunctionIfFunctionPassed: function(){with(this){ + new Mock(Math, 'random', function(arg){ return(arg+1); }); assertEqual(101, Math.random(100)); }}, - testObjectMockReset_WillClearAllMocksLeavingTheDefaultFunction: function(){with(this){ + testMockObjectReset_WillClearAllMocksLeavingTheDefaultFunction: function(){with(this){ var initialRandom = Math.random; - Math.mock('random', 3, 4, 5); - Math.mock('random', 6, 7); + new Mock(Math, 'random', 3, 4, 5); + new Mock(Math, 'random', 6, 7); assertEqual(7, Math.random()); Math.random.reset(); assertEqual(initialRandom, Math.random); @@ -96,8 +90,8 @@ testMockReset_WillClearAllMocks: function(){with(this){ var initialRandom = Math.random, initialSetTimeout = window.setTimeout; - Math.mock('random', 3); - window.mock('setTimeout', 8); + new Mock(Math, 'random', 3); + new Mock(window, 'setTimeout', 8); Mock.reset(); @@ -123,27 +117,42 @@ assertEqual(initialSetTimeout, window.setTimeout); }}, - testWindow_AlsoGetsMocked: function(){with(this){ + testMockInit_MocksWindow: function(){with(this){ + assertEqual(undefined, window.mock); + Mock.init(); assert(window.mock); }}, - testMockNoFootprint_WillRemoveMethodsFromObjects: function(){with(this){ + testMockInit_MocksObjects: function(){with(this){ + assertEqual(undefined, Math.mock); + Mock.init(); + Math.mock('random', 1,2,3); + + assertEqual(3, Math.random()); + assertEqual(2, Math.random()); + }}, + + testObjectMocks_CanBeChained: function(){with(this){ + Mock.init(); + var initialRound = Math.round; + + Math.mock('random', 3).mock('round', 4); + + assertEqual(3, Math.random()); + assertEqual(4, Math.round()); + assertEqual(initialRandom, Math.random); + assertEqual(initialRound, Math.round); + }}, + + testMockNoFootprint_WillRestoreOldMock: function(){with(this){ Mock.noFootprint(); - assertEqual(undefined, {}.mock); - assertEqual(undefined, (function(){}).mock); + assertEqual(undefined, window.Mock); }}, testMockNoFootprint_ReturnsMockObject: function(){with(this){ - var mockObject = Mock; + var mockObject = window.Mock; var returned = Mock.noFootprint(); assertEqual(mockObject, returned); - }}, - - testMockNoFootprintWithArgument_WillRestoreOldMock: function(){with(this){ - var mockObject = Mock.noFootprint(); - assertEqual(mockObject, window.Mock); - Mock.noFootprint(true); - assertEqual(undefined, window.Mock); }} }, "testlog"); tests/mock_test.html 56e4f43972f92e0307f77a202b367fdc58998884 Douglas Meyer douglas.meyer@centro.net http://github.com/DouglasMeyer/jsmock/commit/ba79fc7c09e03c85931976cdd71eb30402a3b5c5 ba79fc7c09e03c85931976cdd71eb30402a3b5c5 2008-08-26T08:02:56-07:00 2008-08-25T15:46:06-07:00 Mocking objects requires you to init first. Updated the test library. Updated the examples. 4e49b7e2c7796a00ee234ea843a2380106590588 Douglas Meyer douglas.meyer@centro.net