diff options
Diffstat (limited to 'resources/jquery/jquery.qunit.completenessTest.js')
| -rw-r--r-- | resources/jquery/jquery.qunit.completenessTest.js | 515 |
1 files changed, 309 insertions, 206 deletions
diff --git a/resources/jquery/jquery.qunit.completenessTest.js b/resources/jquery/jquery.qunit.completenessTest.js index 5abb8691..1475af2a 100644 --- a/resources/jquery/jquery.qunit.completenessTest.js +++ b/resources/jquery/jquery.qunit.completenessTest.js @@ -1,259 +1,362 @@ /** - * jQuery QUnit CompletenessTest 0.3 + * jQuery QUnit CompletenessTest 0.4 * * Tests the completeness of test suites for object oriented javascript * libraries. Written to be used in environments with jQuery and QUnit. - * Requires jQuery 1.5.2 or higher. - * - * Globals: jQuery, QUnit, console.log + * Requires jQuery 1.7.2 or higher. * * Built for and tested with: - * - Safari 5 + * - Chrome 19 * - Firefox 4 + * - Safari 5 * - * @author Timo Tijhof, 2011 - */ -( function( $ ) { - -/** - * CompletenessTest - * @constructor - * - * @example - * var myTester = new CompletenessTest( myLib ); - * @param masterVariable {Object} The root variable that contains all object - * members. CompletenessTest will recursively traverse objects and keep track - * of all methods. - * @param ignoreFn {Function} Optionally pass a function to filter out certain - * methods. Example: You may want to filter out instances of jQuery or some - * other constructor. Otherwise "missingTests" will include all methods that - * were not called from that instance. + * @author Timo Tijhof, 2011-2012 */ -var CompletenessTest = function ( masterVariable, ignoreFn ) { - - // Keep track in these objects. Keyed by strings with the - // method names (ie. 'my.foo', 'my.bar', etc.) values are boolean true. - this.methodCallTracker = {}; - this.missingTests = {}; - - this.ignoreFn = undefined === ignoreFn ? function(){ return false; } : ignoreFn; +/*global jQuery, QUnit */ +/*jshint eqeqeq:false, eqnull:false, forin:false */ +( function ( $ ) { + "use strict"; + + var util, + hasOwn = Object.prototype.hasOwnProperty, + log = (window.console && window.console.log) + ? function () { return window.console.log.apply(window.console, arguments); } + : function () {}; + + // Simplified version of a few jQuery methods, except that they don't + // call other jQuery methods. Required to be able to run the CompletenessTest + // on jQuery itself as well. + util = { + keys: Object.keys || function ( object ) { + var key, keys = []; + for ( key in object ) { + if ( hasOwn.call( object, key ) ) { + keys.push( key ); + } + } + return keys; + }, + extend: function () { + var options, name, src, copy, + target = arguments[0] || {}, + i = 1, + length = arguments.length; + + for ( ; i < length; i++ ) { + options = arguments[ i ]; + // Only deal with non-null/undefined values + if ( options !== null && options !== undefined ) { + // Extend the base object + for ( name in options ) { + src = target[ name ]; + copy = options[ name ]; + + // Prevent never-ending loop + if ( target === copy ) { + continue; + } + + if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } - // Lazy limit in case something weird happends (like recurse (part of) ourself). - this.lazyLimit = 1000; - this.lazyCounter = 0; + // Return the modified object + return target; + }, + each: function ( object, callback ) { + var name; + for ( name in object ) { + if ( callback.call( object[ name ], name, object[ name ] ) === false ) { + break; + } + } + }, + // $.type and $.isEmptyObject are safe as is, they don't call + // other $.* methods. Still need to be derefenced into `util` + // since the CompletenessTest will overload them with spies. + type: $.type, + isEmptyObject: $.isEmptyObject + }; - var that = this; - // Bind begin and end to QUnit. - QUnit.begin = function(){ - that.checkTests( null, masterVariable, masterVariable, [], CompletenessTest.ACTION_INJECT ); - }; + /** + * CompletenessTest + * @constructor + * + * @example + * var myTester = new CompletenessTest( myLib ); + * @param masterVariable {Object} The root variable that contains all object + * members. CompletenessTest will recursively traverse objects and keep track + * of all methods. + * @param ignoreFn {Function} Optionally pass a function to filter out certain + * methods. Example: You may want to filter out instances of jQuery or some + * other constructor. Otherwise "missingTests" will include all methods that + * were not called from that instance. + */ + function CompletenessTest( masterVariable, ignoreFn ) { - QUnit.done = function(){ - that.checkTests( null, masterVariable, masterVariable, [], CompletenessTest.ACTION_CHECK ); - console.log( 'CompletenessTest.ACTION_CHECK', that ); + // Keep track in these objects. Keyed by strings with the + // method names (ie. 'my.foo', 'my.bar', etc.) values are boolean true. + this.injectionTracker = {}; + this.methodCallTracker = {}; + this.missingTests = {}; - // Build HTML representing the outcome from CompletenessTest - // And insert it into the header. + this.ignoreFn = undefined === ignoreFn ? function () { return false; } : ignoreFn; - var makeList = function( blob, title, style ) { - title = title || 'Values'; - var html = '<strong>' + mw.html.escape(title) + '</strong>'; - $.each( blob, function( key ) { - html += '<br />' + mw.html.escape(key); - }); - html += '<br /><br /><em>— CompletenessTest</em>'; - var $oldResult = $( '#qunit-completenesstest' ), - $result = $oldResult.length ? $oldResult : $( '<div id="qunit-completenesstest"></div>' ); - return $result.css( style ).html( html ); - }; - - if ( $.isEmptyObject( that.missingTests ) ) { - // Good - var $testResults = makeList( - { 'No missing tests!': true }, - 'missingTests', - { - background: '#D2E0E6', - color: '#366097', - padding: '1em' - } - ); - } else { - // Bad - var $testResults = makeList( - that.missingTests, - 'missingTests', - { - background: '#EE5757', - color: 'black', - padding: '1em' - } - ); - } + // Lazy limit in case something weird happends (like recurse (part of) ourself). + this.lazyLimit = 2000; + this.lazyCounter = 0; - $( '#qunit-testrunner-toolbar' ).prepend( $testResults ); - }; + var that = this; - return this; -}; + // Bind begin and end to QUnit. + QUnit.begin( function () { + that.walkTheObject( null, masterVariable, masterVariable, [], CompletenessTest.ACTION_INJECT ); + log( 'CompletenessTest/walkTheObject/ACTION_INJECT', that ); + }); -/* Static members */ -CompletenessTest.ACTION_INJECT = 500; -CompletenessTest.ACTION_CHECK = 501; + QUnit.done( function () { + that.populateMissingTests(); + log( 'CompletenessTest/populateMissingTests', that ); -/* Public methods */ -CompletenessTest.fn = CompletenessTest.prototype = { + var toolbar, testResults, cntTotal, cntCalled, cntMissing; - /** - * CompletenessTest.fn.checkTests - * - * This function recursively walks through the given object, calling itself as it goes. - * Depending on the action it either injects our listener into the methods, or - * reads from our tracker and records which methods have not been called by the test suite. - * - * @param currName {String|Null} Name of the given object member (Initially this is null). - * @param currVar {mixed} The variable to check (initially an object, - * further down it could be anything). - * @param masterVariable {Object} Throughout our interation, always keep track of the master/root. - * Initially this is the same as currVar. - * @param parentPathArray {Array} Array of names that indicate our breadcrumb path starting at - * masterVariable. Not including currName. - * @param action {Number} What is this function supposed to do (ACTION_INJECT or ACTION_CHECK) - */ - checkTests: function( currName, currVar, masterVariable, parentPathArray, action ) { + cntTotal = util.keys( that.injectionTracker ).length; + cntCalled = util.keys( that.methodCallTracker ).length; + cntMissing = util.keys( that.missingTests ).length; - // Handle the lazy limit - this.lazyCounter++; - if ( this.lazyCounter > this.lazyLimit ) { - console.log( 'CompletenessTest.fn.checkTests> Limit reached: ' + this.lazyCounter ); - return null; - } + function makeTestResults( blob, title, style ) { + var elOutputWrapper, elTitle, elContainer, elList, elFoot; - var type = $.type( currVar ), - that = this; + elTitle = document.createElement( 'strong' ); + elTitle.textContent = title || 'Values'; - // Hard ignores - if ( this.ignoreFn( currVar, that, parentPathArray ) ) { - return null; + elList = document.createElement( 'ul' ); + util.each( blob, function ( key ) { + var elItem = document.createElement( 'li' ); + elItem.textContent = key; + elList.appendChild( elItem ); + }); - // Functions - } else if ( type === 'function' ) { + elFoot = document.createElement( 'p' ); + elFoot.innerHTML = '<em>— CompletenessTest</em>'; - /* CHECK MODE */ + elContainer = document.createElement( 'div' ); + elContainer.appendChild( elTitle ); + elContainer.appendChild( elList ); + elContainer.appendChild( elFoot ); - if ( action === CompletenessTest.ACTION_CHECK ) { + elOutputWrapper = document.getElementById( 'qunit-completenesstest' ); + if ( !elOutputWrapper ) { + elOutputWrapper = document.createElement( 'div' ); + elOutputWrapper.id = 'qunit-completenesstest'; + } + elOutputWrapper.appendChild( elContainer ); - if ( !currVar.prototype || $.isEmptyObject( currVar.prototype ) ) { + util.each( style, function ( key, value ) { + elOutputWrapper.style[key] = value; + }); + return elOutputWrapper; + } - that.hasTest( parentPathArray.join( '.' ) ); + if ( cntMissing === 0 ) { + // Good + testResults = makeTestResults( + {}, + 'Detected calls to ' + cntCalled + '/' + cntTotal + ' methods. No missing tests!', + { + backgroundColor: '#D2E0E6', + color: '#366097', + paddingTop: '1em', + paddingRight: '1em', + paddingBottom: '1em', + paddingLeft: '1em' + } + ); + } else { + // Bad + testResults = makeTestResults( + that.missingTests, + 'Detected calls to ' + cntCalled + '/' + cntTotal + ' methods. ' + cntMissing + ' methods not covered:', + { + backgroundColor: '#EE5757', + color: 'black', + paddingTop: '1em', + paddingRight: '1em', + paddingBottom: '1em', + paddingLeft: '1em' + } + ); + } - // We don't support checking object constructors yet... - } else { + toolbar = document.getElementById( 'qunit-testrunner-toolbar' ); + if ( toolbar ) { + toolbar.insertBefore( testResults, toolbar.firstChild ); + } + }); - // ...the prototypes are fine tho - $.each( currVar.prototype, function( key, value ) { - if ( key === 'constructor' ) return; + return this; + } - // Clone and break reference to parentPathArray - var tmpPathArray = $.extend( [], parentPathArray ); - tmpPathArray.push( 'prototype' ); tmpPathArray.push( key ); + /* Static members */ + CompletenessTest.ACTION_INJECT = 500; + CompletenessTest.ACTION_CHECK = 501; + + /* Public methods */ + CompletenessTest.fn = CompletenessTest.prototype = { + + /** + * CompletenessTest.fn.walkTheObject + * + * This function recursively walks through the given object, calling itself as it goes. + * Depending on the action it either injects our listener into the methods, or + * reads from our tracker and records which methods have not been called by the test suite. + * + * @param currName {String|Null} Name of the given object member (Initially this is null). + * @param currVar {mixed} The variable to check (initially an object, + * further down it could be anything). + * @param masterVariable {Object} Throughout our interation, always keep track of the master/root. + * Initially this is the same as currVar. + * @param parentPathArray {Array} Array of names that indicate our breadcrumb path starting at + * masterVariable. Not including currName. + * @param action {Number} What is this function supposed to do (ACTION_INJECT or ACTION_CHECK) + */ + walkTheObject: function ( currName, currVar, masterVariable, parentPathArray, action ) { + + var key, value, tmpPathArray, + type = util.type( currVar ), + that = this; + + // Hard ignores + if ( this.ignoreFn( currVar, that, parentPathArray ) ) { + return null; + } - that.hasTest( tmpPathArray.join( '.' ) ); - } ); - } + // Handle the lazy limit + this.lazyCounter++; + if ( this.lazyCounter > this.lazyLimit ) { + log( 'CompletenessTest.fn.walkTheObject> Limit reached: ' + this.lazyCounter, parentPathArray ); + return null; + } - /* INJECT MODE */ + // Functions + if ( type === 'function' ) { - } else if ( action === CompletenessTest.ACTION_INJECT ) { + if ( !currVar.prototype || util.isEmptyObject( currVar.prototype ) ) { - if ( !currVar.prototype || $.isEmptyObject( currVar.prototype ) ) { + if ( action === CompletenessTest.ACTION_INJECT ) { - // Inject check - that.injectCheck( masterVariable, parentPathArray, function() { - that.methodCallTracker[ parentPathArray.join( '.' ) ] = true; - } ); + that.injectionTracker[ parentPathArray.join( '.' ) ] = true; + that.injectCheck( masterVariable, parentPathArray, function () { + that.methodCallTracker[ parentPathArray.join( '.' ) ] = true; + } ); + } // We don't support checking object constructors yet... + // ...we can check the prototypes fine, though. } else { + if ( action === CompletenessTest.ACTION_INJECT ) { - // ... the prototypes are fine tho - $.each( currVar.prototype, function( key, value ) { - if ( key === 'constructor' ) return; + for ( key in currVar.prototype ) { + if ( hasOwn.call( currVar.prototype, key ) ) { + value = currVar.prototype[key]; + if ( key === 'constructor' ) { + continue; + } - // Clone and break reference to parentPathArray - var tmpPathArray = $.extend( [], parentPathArray ); - tmpPathArray.push( 'prototype' ); tmpPathArray.push( key ); + // Clone and break reference to parentPathArray + tmpPathArray = util.extend( [], parentPathArray ); + tmpPathArray.push( 'prototype' ); + tmpPathArray.push( key ); + + that.walkTheObject( key, value, masterVariable, tmpPathArray, action ); + } + } - that.checkTests( key, value, masterVariable, tmpPathArray, action ); - } ); + } } } - // Recursively. After all, this *is* the completeness test - } else if ( type === 'object' ) { - - $.each( currVar, function( key, value ) { - - // Clone and break reference to parentPathArray - var tmpPathArray = $.extend( [], parentPathArray ); - tmpPathArray.push( key ); + // Recursively. After all, this is the *completeness* test + if ( type === 'function' || type === 'object' ) { + for ( key in currVar ) { + if ( hasOwn.call( currVar, key ) ) { + value = currVar[key]; - that.checkTests( key, value, masterVariable, tmpPathArray, action ); + // Clone and break reference to parentPathArray + tmpPathArray = util.extend( [], parentPathArray ); + tmpPathArray.push( key ); - } ); + that.walkTheObject( key, value, masterVariable, tmpPathArray, action ); + } + } + } + }, - } - }, + populateMissingTests: function () { + var ct = this; + util.each( ct.injectionTracker, function ( key ) { + ct.hasTest( key ); + }); + }, + + /** + * CompletenessTest.fn.hasTest + * + * Checks if the given method name (ie. 'my.foo.bar') + * was called during the test suite (as far as the tracker knows). + * If not it adds it to missingTests. + * + * @param fnName {String} + * @return {Boolean} + */ + hasTest: function ( fnName ) { + if ( !( fnName in this.methodCallTracker ) ) { + this.missingTests[fnName] = true; + return false; + } + return true; + }, + + /** + * CompletenessTest.fn.injectCheck + * + * Injects a function (such as a spy that updates methodCallTracker when + * it's called) inside another function. + * + * @param masterVariable {Object} + * @param objectPathArray {Array} + * @param injectFn {Function} + */ + injectCheck: function ( masterVariable, objectPathArray, injectFn ) { + var i, len, prev, memberName, lastMember, + curr = masterVariable; + + // Get the object in question through the path from the master variable, + // We can't pass the value directly because we need to re-define the object + // member and keep references to the parent object, member name and member + // value at all times. + for ( i = 0, len = objectPathArray.length; i < len; i++ ) { + memberName = objectPathArray[i]; + + prev = curr; + curr = prev[memberName]; + lastMember = memberName; + } - /** - * CompletenessTest.fn.hasTest - * - * Checks if the given method name (ie. 'my.foo.bar') - * was called during the test suite (as far as the tracker knows). - * If not it adds it to missingTests. - * - * @param fnName {String} - * @return {Boolean} - */ - hasTest: function( fnName ) { - if ( !( fnName in this.methodCallTracker ) ) { - this.missingTests[fnName] = true; - return false; + // Objects are by reference, members (unless objects) are not. + prev[lastMember] = function () { + injectFn(); + return curr.apply( this, arguments ); + }; } - return true; - }, - - /** - * CompletenessTest.fn.injectCheck - * - * Injects a function (such as a spy that updates methodCallTracker when - * it's called) inside another function. - * - * @param masterVariable {Object} - * @param objectPathArray {Array} - * @param injectFn {Function} - */ - injectCheck: function( masterVariable, objectPathArray, injectFn ) { - var prev, - curr = masterVariable, - lastMember; - - $.each( objectPathArray, function( i, memberName ) { - prev = curr; - curr = prev[memberName]; - lastMember = memberName; - }); - - // Objects are by reference, members (unless objects) are not. - prev[lastMember] = function() { - injectFn(); - return curr.apply( this, arguments ); - }; - } -}; + }; -window.CompletenessTest = CompletenessTest; + /* Expose */ + window.CompletenessTest = CompletenessTest; -} )( jQuery ); +}( jQuery ) ); |