From 741661ff9c09bd635d7ee13a9282f772890d977c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Fri, 3 Apr 2015 15:21:16 -0400 Subject: [PATCH 01/29] Tests: Change test infrastructure to use AMD and reduce boilerplate * Adds RequireJS and relies on AMD for loading dependencies. * Updates to grunt-contrib-qunit 0.6.0. * Convert `domEqual()` to a proper QUnit assertion. * Introduces two bootstrap files (JS and CSS) which use `data-` attributes to reduce the amount of boilerplate needed in each test --- Gruntfile.js | 3 + bower.json | 1 + external/requirejs/require.js | 2076 ++++++++++++++++++++++++++++ package.json | 2 +- tests/.jshintrc | 1 + tests/lib/bootstrap.js | 146 ++ tests/lib/common.js | 133 ++ tests/lib/css.js | 23 + tests/lib/helper.js | 33 + tests/lib/qunit-assert-domequal.js | 122 ++ tests/lib/qunit.js | 45 + 11 files changed, 2584 insertions(+), 1 deletion(-) create mode 100644 external/requirejs/require.js create mode 100644 tests/lib/bootstrap.js create mode 100644 tests/lib/common.js create mode 100644 tests/lib/css.js create mode 100644 tests/lib/helper.js create mode 100644 tests/lib/qunit-assert-domequal.js create mode 100644 tests/lib/qunit.js diff --git a/Gruntfile.js b/Gruntfile.js index 53b34280ab6..b9a3a792b7a 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -225,6 +225,7 @@ grunt.initConfig({ return !( /(all|index|test)\.html$/ ).test( file ); }), options: { + inject: false, page: { viewportSize: { width: 700, height: 500 } } @@ -284,6 +285,8 @@ grunt.initConfig({ "qunit-composite/qunit-composite.css": "qunit-composite/qunit-composite.css", "qunit-composite/LICENSE.txt": "qunit-composite/LICENSE.txt", + "requirejs/require.js": "requirejs/require.js", + "jquery-mousewheel/jquery.mousewheel.js": "jquery-mousewheel/jquery.mousewheel.js", "jquery-mousewheel/LICENSE.txt": "jquery-mousewheel/LICENSE.txt", diff --git a/bower.json b/bower.json index cdeb87791fa..e371c03c4b8 100644 --- a/bower.json +++ b/bower.json @@ -17,6 +17,7 @@ "qunit": "1.18.0", "qunit-assert-classes": "0.1.5", "qunit-composite": "JamesMGreene/qunit-composite#v1.0.4", + "requirejs": "2.1.14", "jquery-1.7.0": "jquery#1.7.0", "jquery-1.7.1": "jquery#1.7.1", diff --git a/external/requirejs/require.js b/external/requirejs/require.js new file mode 100644 index 00000000000..7f31fa20417 --- /dev/null +++ b/external/requirejs/require.js @@ -0,0 +1,2076 @@ +/** vim: et:ts=4:sw=4:sts=4 + * @license RequireJS 2.1.14 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved. + * Available via the MIT or new BSD license. + * see: http://github.com/jrburke/requirejs for details + */ +//Not using strict: uneven strict support in browsers, #392, and causes +//problems with requirejs.exec()/transpiler plugins that may not be strict. +/*jslint regexp: true, nomen: true, sloppy: true */ +/*global window, navigator, document, importScripts, setTimeout, opera */ + +var requirejs, require, define; +(function (global) { + var req, s, head, baseElement, dataMain, src, + interactiveScript, currentlyAddingScript, mainScript, subPath, + version = '2.1.14', + commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg, + cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g, + jsSuffixRegExp = /\.js$/, + currDirRegExp = /^\.\//, + op = Object.prototype, + ostring = op.toString, + hasOwn = op.hasOwnProperty, + ap = Array.prototype, + apsp = ap.splice, + isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document), + isWebWorker = !isBrowser && typeof importScripts !== 'undefined', + //PS3 indicates loaded and complete, but need to wait for complete + //specifically. Sequence is 'loading', 'loaded', execution, + // then 'complete'. The UA check is unfortunate, but not sure how + //to feature test w/o causing perf issues. + readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ? + /^complete$/ : /^(complete|loaded)$/, + defContextName = '_', + //Oh the tragedy, detecting opera. See the usage of isOpera for reason. + isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]', + contexts = {}, + cfg = {}, + globalDefQueue = [], + useInteractive = false; + + function isFunction(it) { + return ostring.call(it) === '[object Function]'; + } + + function isArray(it) { + return ostring.call(it) === '[object Array]'; + } + + /** + * Helper function for iterating over an array. If the func returns + * a true value, it will break out of the loop. + */ + function each(ary, func) { + if (ary) { + var i; + for (i = 0; i < ary.length; i += 1) { + if (ary[i] && func(ary[i], i, ary)) { + break; + } + } + } + } + + /** + * Helper function for iterating over an array backwards. If the func + * returns a true value, it will break out of the loop. + */ + function eachReverse(ary, func) { + if (ary) { + var i; + for (i = ary.length - 1; i > -1; i -= 1) { + if (ary[i] && func(ary[i], i, ary)) { + break; + } + } + } + } + + function hasProp(obj, prop) { + return hasOwn.call(obj, prop); + } + + function getOwn(obj, prop) { + return hasProp(obj, prop) && obj[prop]; + } + + /** + * Cycles over properties in an object and calls a function for each + * property value. If the function returns a truthy value, then the + * iteration is stopped. + */ + function eachProp(obj, func) { + var prop; + for (prop in obj) { + if (hasProp(obj, prop)) { + if (func(obj[prop], prop)) { + break; + } + } + } + } + + /** + * Simple function to mix in properties from source into target, + * but only if target does not already have a property of the same name. + */ + function mixin(target, source, force, deepStringMixin) { + if (source) { + eachProp(source, function (value, prop) { + if (force || !hasProp(target, prop)) { + if (deepStringMixin && typeof value === 'object' && value && + !isArray(value) && !isFunction(value) && + !(value instanceof RegExp)) { + + if (!target[prop]) { + target[prop] = {}; + } + mixin(target[prop], value, force, deepStringMixin); + } else { + target[prop] = value; + } + } + }); + } + return target; + } + + //Similar to Function.prototype.bind, but the 'this' object is specified + //first, since it is easier to read/figure out what 'this' will be. + function bind(obj, fn) { + return function () { + return fn.apply(obj, arguments); + }; + } + + function scripts() { + return document.getElementsByTagName('script'); + } + + function defaultOnError(err) { + throw err; + } + + //Allow getting a global that is expressed in + //dot notation, like 'a.b.c'. + function getGlobal(value) { + if (!value) { + return value; + } + var g = global; + each(value.split('.'), function (part) { + g = g[part]; + }); + return g; + } + + /** + * Constructs an error with a pointer to an URL with more information. + * @param {String} id the error ID that maps to an ID on a web page. + * @param {String} message human readable error. + * @param {Error} [err] the original error, if there is one. + * + * @returns {Error} + */ + function makeError(id, msg, err, requireModules) { + var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id); + e.requireType = id; + e.requireModules = requireModules; + if (err) { + e.originalError = err; + } + return e; + } + + if (typeof define !== 'undefined') { + //If a define is already in play via another AMD loader, + //do not overwrite. + return; + } + + if (typeof requirejs !== 'undefined') { + if (isFunction(requirejs)) { + //Do not overwrite an existing requirejs instance. + return; + } + cfg = requirejs; + requirejs = undefined; + } + + //Allow for a require config object + if (typeof require !== 'undefined' && !isFunction(require)) { + //assume it is a config object. + cfg = require; + require = undefined; + } + + function newContext(contextName) { + var inCheckLoaded, Module, context, handlers, + checkLoadedTimeoutId, + config = { + //Defaults. Do not set a default for map + //config to speed up normalize(), which + //will run faster if there is no default. + waitSeconds: 7, + baseUrl: './', + paths: {}, + bundles: {}, + pkgs: {}, + shim: {}, + config: {} + }, + registry = {}, + //registry of just enabled modules, to speed + //cycle breaking code when lots of modules + //are registered, but not activated. + enabledRegistry = {}, + undefEvents = {}, + defQueue = [], + defined = {}, + urlFetched = {}, + bundlesMap = {}, + requireCounter = 1, + unnormalizedCounter = 1; + + /** + * Trims the . and .. from an array of path segments. + * It will keep a leading path segment if a .. will become + * the first path segment, to help with module name lookups, + * which act like paths, but can be remapped. But the end result, + * all paths that use this function should look normalized. + * NOTE: this method MODIFIES the input array. + * @param {Array} ary the array of path segments. + */ + function trimDots(ary) { + var i, part; + for (i = 0; i < ary.length; i++) { + part = ary[i]; + if (part === '.') { + ary.splice(i, 1); + i -= 1; + } else if (part === '..') { + // If at the start, or previous value is still .., + // keep them so that when converted to a path it may + // still work when converted to a path, even though + // as an ID it is less than ideal. In larger point + // releases, may be better to just kick out an error. + if (i === 0 || (i == 1 && ary[2] === '..') || ary[i - 1] === '..') { + continue; + } else if (i > 0) { + ary.splice(i - 1, 2); + i -= 2; + } + } + } + } + + /** + * Given a relative module name, like ./something, normalize it to + * a real name that can be mapped to a path. + * @param {String} name the relative name + * @param {String} baseName a real name that the name arg is relative + * to. + * @param {Boolean} applyMap apply the map config to the value. Should + * only be done if this normalization is for a dependency ID. + * @returns {String} normalized name + */ + function normalize(name, baseName, applyMap) { + var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex, + foundMap, foundI, foundStarMap, starI, normalizedBaseParts, + baseParts = (baseName && baseName.split('/')), + map = config.map, + starMap = map && map['*']; + + //Adjust any relative paths. + if (name) { + name = name.split('/'); + lastIndex = name.length - 1; + + // If wanting node ID compatibility, strip .js from end + // of IDs. Have to do this here, and not in nameToUrl + // because node allows either .js or non .js to map + // to same file. + if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { + name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ''); + } + + // Starts with a '.' so need the baseName + if (name[0].charAt(0) === '.' && baseParts) { + //Convert baseName to array, and lop off the last part, + //so that . matches that 'directory' and not name of the baseName's + //module. For instance, baseName of 'one/two/three', maps to + //'one/two/three.js', but we want the directory, 'one/two' for + //this normalization. + normalizedBaseParts = baseParts.slice(0, baseParts.length - 1); + name = normalizedBaseParts.concat(name); + } + + trimDots(name); + name = name.join('/'); + } + + //Apply map config if available. + if (applyMap && map && (baseParts || starMap)) { + nameParts = name.split('/'); + + outerLoop: for (i = nameParts.length; i > 0; i -= 1) { + nameSegment = nameParts.slice(0, i).join('/'); + + if (baseParts) { + //Find the longest baseName segment match in the config. + //So, do joins on the biggest to smallest lengths of baseParts. + for (j = baseParts.length; j > 0; j -= 1) { + mapValue = getOwn(map, baseParts.slice(0, j).join('/')); + + //baseName segment has config, find if it has one for + //this name. + if (mapValue) { + mapValue = getOwn(mapValue, nameSegment); + if (mapValue) { + //Match, update name to the new value. + foundMap = mapValue; + foundI = i; + break outerLoop; + } + } + } + } + + //Check for a star map match, but just hold on to it, + //if there is a shorter segment match later in a matching + //config, then favor over this star map. + if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) { + foundStarMap = getOwn(starMap, nameSegment); + starI = i; + } + } + + if (!foundMap && foundStarMap) { + foundMap = foundStarMap; + foundI = starI; + } + + if (foundMap) { + nameParts.splice(0, foundI, foundMap); + name = nameParts.join('/'); + } + } + + // If the name points to a package's name, use + // the package main instead. + pkgMain = getOwn(config.pkgs, name); + + return pkgMain ? pkgMain : name; + } + + function removeScript(name) { + if (isBrowser) { + each(scripts(), function (scriptNode) { + if (scriptNode.getAttribute('data-requiremodule') === name && + scriptNode.getAttribute('data-requirecontext') === context.contextName) { + scriptNode.parentNode.removeChild(scriptNode); + return true; + } + }); + } + } + + function hasPathFallback(id) { + var pathConfig = getOwn(config.paths, id); + if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) { + //Pop off the first array value, since it failed, and + //retry + pathConfig.shift(); + context.require.undef(id); + + //Custom require that does not do map translation, since + //ID is "absolute", already mapped/resolved. + context.makeRequire(null, { + skipMap: true + })([id]); + + return true; + } + } + + //Turns a plugin!resource to [plugin, resource] + //with the plugin being undefined if the name + //did not have a plugin prefix. + function splitPrefix(name) { + var prefix, + index = name ? name.indexOf('!') : -1; + if (index > -1) { + prefix = name.substring(0, index); + name = name.substring(index + 1, name.length); + } + return [prefix, name]; + } + + /** + * Creates a module mapping that includes plugin prefix, module + * name, and path. If parentModuleMap is provided it will + * also normalize the name via require.normalize() + * + * @param {String} name the module name + * @param {String} [parentModuleMap] parent module map + * for the module name, used to resolve relative names. + * @param {Boolean} isNormalized: is the ID already normalized. + * This is true if this call is done for a define() module ID. + * @param {Boolean} applyMap: apply the map config to the ID. + * Should only be true if this map is for a dependency. + * + * @returns {Object} + */ + function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) { + var url, pluginModule, suffix, nameParts, + prefix = null, + parentName = parentModuleMap ? parentModuleMap.name : null, + originalName = name, + isDefine = true, + normalizedName = ''; + + //If no name, then it means it is a require call, generate an + //internal name. + if (!name) { + isDefine = false; + name = '_@r' + (requireCounter += 1); + } + + nameParts = splitPrefix(name); + prefix = nameParts[0]; + name = nameParts[1]; + + if (prefix) { + prefix = normalize(prefix, parentName, applyMap); + pluginModule = getOwn(defined, prefix); + } + + //Account for relative paths if there is a base name. + if (name) { + if (prefix) { + if (pluginModule && pluginModule.normalize) { + //Plugin is loaded, use its normalize method. + normalizedName = pluginModule.normalize(name, function (name) { + return normalize(name, parentName, applyMap); + }); + } else { + // If nested plugin references, then do not try to + // normalize, as it will not normalize correctly. This + // places a restriction on resourceIds, and the longer + // term solution is not to normalize until plugins are + // loaded and all normalizations to allow for async + // loading of a loader plugin. But for now, fixes the + // common uses. Details in #1131 + normalizedName = name.indexOf('!') === -1 ? + normalize(name, parentName, applyMap) : + name; + } + } else { + //A regular module. + normalizedName = normalize(name, parentName, applyMap); + + //Normalized name may be a plugin ID due to map config + //application in normalize. The map config values must + //already be normalized, so do not need to redo that part. + nameParts = splitPrefix(normalizedName); + prefix = nameParts[0]; + normalizedName = nameParts[1]; + isNormalized = true; + + url = context.nameToUrl(normalizedName); + } + } + + //If the id is a plugin id that cannot be determined if it needs + //normalization, stamp it with a unique ID so two matching relative + //ids that may conflict can be separate. + suffix = prefix && !pluginModule && !isNormalized ? + '_unnormalized' + (unnormalizedCounter += 1) : + ''; + + return { + prefix: prefix, + name: normalizedName, + parentMap: parentModuleMap, + unnormalized: !!suffix, + url: url, + originalName: originalName, + isDefine: isDefine, + id: (prefix ? + prefix + '!' + normalizedName : + normalizedName) + suffix + }; + } + + function getModule(depMap) { + var id = depMap.id, + mod = getOwn(registry, id); + + if (!mod) { + mod = registry[id] = new context.Module(depMap); + } + + return mod; + } + + function on(depMap, name, fn) { + var id = depMap.id, + mod = getOwn(registry, id); + + if (hasProp(defined, id) && + (!mod || mod.defineEmitComplete)) { + if (name === 'defined') { + fn(defined[id]); + } + } else { + mod = getModule(depMap); + if (mod.error && name === 'error') { + fn(mod.error); + } else { + mod.on(name, fn); + } + } + } + + function onError(err, errback) { + var ids = err.requireModules, + notified = false; + + if (errback) { + errback(err); + } else { + each(ids, function (id) { + var mod = getOwn(registry, id); + if (mod) { + //Set error on module, so it skips timeout checks. + mod.error = err; + if (mod.events.error) { + notified = true; + mod.emit('error', err); + } + } + }); + + if (!notified) { + req.onError(err); + } + } + } + + /** + * Internal method to transfer globalQueue items to this context's + * defQueue. + */ + function takeGlobalQueue() { + //Push all the globalDefQueue items into the context's defQueue + if (globalDefQueue.length) { + //Array splice in the values since the context code has a + //local var ref to defQueue, so cannot just reassign the one + //on context. + apsp.apply(defQueue, + [defQueue.length, 0].concat(globalDefQueue)); + globalDefQueue = []; + } + } + + handlers = { + 'require': function (mod) { + if (mod.require) { + return mod.require; + } else { + return (mod.require = context.makeRequire(mod.map)); + } + }, + 'exports': function (mod) { + mod.usingExports = true; + if (mod.map.isDefine) { + if (mod.exports) { + return (defined[mod.map.id] = mod.exports); + } else { + return (mod.exports = defined[mod.map.id] = {}); + } + } + }, + 'module': function (mod) { + if (mod.module) { + return mod.module; + } else { + return (mod.module = { + id: mod.map.id, + uri: mod.map.url, + config: function () { + return getOwn(config.config, mod.map.id) || {}; + }, + exports: mod.exports || (mod.exports = {}) + }); + } + } + }; + + function cleanRegistry(id) { + //Clean up machinery used for waiting modules. + delete registry[id]; + delete enabledRegistry[id]; + } + + function breakCycle(mod, traced, processed) { + var id = mod.map.id; + + if (mod.error) { + mod.emit('error', mod.error); + } else { + traced[id] = true; + each(mod.depMaps, function (depMap, i) { + var depId = depMap.id, + dep = getOwn(registry, depId); + + //Only force things that have not completed + //being defined, so still in the registry, + //and only if it has not been matched up + //in the module already. + if (dep && !mod.depMatched[i] && !processed[depId]) { + if (getOwn(traced, depId)) { + mod.defineDep(i, defined[depId]); + mod.check(); //pass false? + } else { + breakCycle(dep, traced, processed); + } + } + }); + processed[id] = true; + } + } + + function checkLoaded() { + var err, usingPathFallback, + waitInterval = config.waitSeconds * 1000, + //It is possible to disable the wait interval by using waitSeconds of 0. + expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(), + noLoads = [], + reqCalls = [], + stillLoading = false, + needCycleCheck = true; + + //Do not bother if this call was a result of a cycle break. + if (inCheckLoaded) { + return; + } + + inCheckLoaded = true; + + //Figure out the state of all the modules. + eachProp(enabledRegistry, function (mod) { + var map = mod.map, + modId = map.id; + + //Skip things that are not enabled or in error state. + if (!mod.enabled) { + return; + } + + if (!map.isDefine) { + reqCalls.push(mod); + } + + if (!mod.error) { + //If the module should be executed, and it has not + //been inited and time is up, remember it. + if (!mod.inited && expired) { + if (hasPathFallback(modId)) { + usingPathFallback = true; + stillLoading = true; + } else { + noLoads.push(modId); + removeScript(modId); + } + } else if (!mod.inited && mod.fetched && map.isDefine) { + stillLoading = true; + if (!map.prefix) { + //No reason to keep looking for unfinished + //loading. If the only stillLoading is a + //plugin resource though, keep going, + //because it may be that a plugin resource + //is waiting on a non-plugin cycle. + return (needCycleCheck = false); + } + } + } + }); + + if (expired && noLoads.length) { + //If wait time expired, throw error of unloaded modules. + err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads); + err.contextName = context.contextName; + return onError(err); + } + + //Not expired, check for a cycle. + if (needCycleCheck) { + each(reqCalls, function (mod) { + breakCycle(mod, {}, {}); + }); + } + + //If still waiting on loads, and the waiting load is something + //other than a plugin resource, or there are still outstanding + //scripts, then just try back later. + if ((!expired || usingPathFallback) && stillLoading) { + //Something is still waiting to load. Wait for it, but only + //if a timeout is not already in effect. + if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) { + checkLoadedTimeoutId = setTimeout(function () { + checkLoadedTimeoutId = 0; + checkLoaded(); + }, 50); + } + } + + inCheckLoaded = false; + } + + Module = function (map) { + this.events = getOwn(undefEvents, map.id) || {}; + this.map = map; + this.shim = getOwn(config.shim, map.id); + this.depExports = []; + this.depMaps = []; + this.depMatched = []; + this.pluginMaps = {}; + this.depCount = 0; + + /* this.exports this.factory + this.depMaps = [], + this.enabled, this.fetched + */ + }; + + Module.prototype = { + init: function (depMaps, factory, errback, options) { + options = options || {}; + + //Do not do more inits if already done. Can happen if there + //are multiple define calls for the same module. That is not + //a normal, common case, but it is also not unexpected. + if (this.inited) { + return; + } + + this.factory = factory; + + if (errback) { + //Register for errors on this module. + this.on('error', errback); + } else if (this.events.error) { + //If no errback already, but there are error listeners + //on this module, set up an errback to pass to the deps. + errback = bind(this, function (err) { + this.emit('error', err); + }); + } + + //Do a copy of the dependency array, so that + //source inputs are not modified. For example + //"shim" deps are passed in here directly, and + //doing a direct modification of the depMaps array + //would affect that config. + this.depMaps = depMaps && depMaps.slice(0); + + this.errback = errback; + + //Indicate this module has be initialized + this.inited = true; + + this.ignore = options.ignore; + + //Could have option to init this module in enabled mode, + //or could have been previously marked as enabled. However, + //the dependencies are not known until init is called. So + //if enabled previously, now trigger dependencies as enabled. + if (options.enabled || this.enabled) { + //Enable this module and dependencies. + //Will call this.check() + this.enable(); + } else { + this.check(); + } + }, + + defineDep: function (i, depExports) { + //Because of cycles, defined callback for a given + //export can be called more than once. + if (!this.depMatched[i]) { + this.depMatched[i] = true; + this.depCount -= 1; + this.depExports[i] = depExports; + } + }, + + fetch: function () { + if (this.fetched) { + return; + } + this.fetched = true; + + context.startTime = (new Date()).getTime(); + + var map = this.map; + + //If the manager is for a plugin managed resource, + //ask the plugin to load it now. + if (this.shim) { + context.makeRequire(this.map, { + enableBuildCallback: true + })(this.shim.deps || [], bind(this, function () { + return map.prefix ? this.callPlugin() : this.load(); + })); + } else { + //Regular dependency. + return map.prefix ? this.callPlugin() : this.load(); + } + }, + + load: function () { + var url = this.map.url; + + //Regular dependency. + if (!urlFetched[url]) { + urlFetched[url] = true; + context.load(this.map.id, url); + } + }, + + /** + * Checks if the module is ready to define itself, and if so, + * define it. + */ + check: function () { + if (!this.enabled || this.enabling) { + return; + } + + var err, cjsModule, + id = this.map.id, + depExports = this.depExports, + exports = this.exports, + factory = this.factory; + + if (!this.inited) { + this.fetch(); + } else if (this.error) { + this.emit('error', this.error); + } else if (!this.defining) { + //The factory could trigger another require call + //that would result in checking this module to + //define itself again. If already in the process + //of doing that, skip this work. + this.defining = true; + + if (this.depCount < 1 && !this.defined) { + if (isFunction(factory)) { + //If there is an error listener, favor passing + //to that instead of throwing an error. However, + //only do it for define()'d modules. require + //errbacks should not be called for failures in + //their callbacks (#699). However if a global + //onError is set, use that. + if ((this.events.error && this.map.isDefine) || + req.onError !== defaultOnError) { + try { + exports = context.execCb(id, factory, depExports, exports); + } catch (e) { + err = e; + } + } else { + exports = context.execCb(id, factory, depExports, exports); + } + + // Favor return value over exports. If node/cjs in play, + // then will not have a return value anyway. Favor + // module.exports assignment over exports object. + if (this.map.isDefine && exports === undefined) { + cjsModule = this.module; + if (cjsModule) { + exports = cjsModule.exports; + } else if (this.usingExports) { + //exports already set the defined value. + exports = this.exports; + } + } + + if (err) { + err.requireMap = this.map; + err.requireModules = this.map.isDefine ? [this.map.id] : null; + err.requireType = this.map.isDefine ? 'define' : 'require'; + return onError((this.error = err)); + } + + } else { + //Just a literal value + exports = factory; + } + + this.exports = exports; + + if (this.map.isDefine && !this.ignore) { + defined[id] = exports; + + if (req.onResourceLoad) { + req.onResourceLoad(context, this.map, this.depMaps); + } + } + + //Clean up + cleanRegistry(id); + + this.defined = true; + } + + //Finished the define stage. Allow calling check again + //to allow define notifications below in the case of a + //cycle. + this.defining = false; + + if (this.defined && !this.defineEmitted) { + this.defineEmitted = true; + this.emit('defined', this.exports); + this.defineEmitComplete = true; + } + + } + }, + + callPlugin: function () { + var map = this.map, + id = map.id, + //Map already normalized the prefix. + pluginMap = makeModuleMap(map.prefix); + + //Mark this as a dependency for this plugin, so it + //can be traced for cycles. + this.depMaps.push(pluginMap); + + on(pluginMap, 'defined', bind(this, function (plugin) { + var load, normalizedMap, normalizedMod, + bundleId = getOwn(bundlesMap, this.map.id), + name = this.map.name, + parentName = this.map.parentMap ? this.map.parentMap.name : null, + localRequire = context.makeRequire(map.parentMap, { + enableBuildCallback: true + }); + + //If current map is not normalized, wait for that + //normalized name to load instead of continuing. + if (this.map.unnormalized) { + //Normalize the ID if the plugin allows it. + if (plugin.normalize) { + name = plugin.normalize(name, function (name) { + return normalize(name, parentName, true); + }) || ''; + } + + //prefix and name should already be normalized, no need + //for applying map config again either. + normalizedMap = makeModuleMap(map.prefix + '!' + name, + this.map.parentMap); + on(normalizedMap, + 'defined', bind(this, function (value) { + this.init([], function () { return value; }, null, { + enabled: true, + ignore: true + }); + })); + + normalizedMod = getOwn(registry, normalizedMap.id); + if (normalizedMod) { + //Mark this as a dependency for this plugin, so it + //can be traced for cycles. + this.depMaps.push(normalizedMap); + + if (this.events.error) { + normalizedMod.on('error', bind(this, function (err) { + this.emit('error', err); + })); + } + normalizedMod.enable(); + } + + return; + } + + //If a paths config, then just load that file instead to + //resolve the plugin, as it is built into that paths layer. + if (bundleId) { + this.map.url = context.nameToUrl(bundleId); + this.load(); + return; + } + + load = bind(this, function (value) { + this.init([], function () { return value; }, null, { + enabled: true + }); + }); + + load.error = bind(this, function (err) { + this.inited = true; + this.error = err; + err.requireModules = [id]; + + //Remove temp unnormalized modules for this module, + //since they will never be resolved otherwise now. + eachProp(registry, function (mod) { + if (mod.map.id.indexOf(id + '_unnormalized') === 0) { + cleanRegistry(mod.map.id); + } + }); + + onError(err); + }); + + //Allow plugins to load other code without having to know the + //context or how to 'complete' the load. + load.fromText = bind(this, function (text, textAlt) { + /*jslint evil: true */ + var moduleName = map.name, + moduleMap = makeModuleMap(moduleName), + hasInteractive = useInteractive; + + //As of 2.1.0, support just passing the text, to reinforce + //fromText only being called once per resource. Still + //support old style of passing moduleName but discard + //that moduleName in favor of the internal ref. + if (textAlt) { + text = textAlt; + } + + //Turn off interactive script matching for IE for any define + //calls in the text, then turn it back on at the end. + if (hasInteractive) { + useInteractive = false; + } + + //Prime the system by creating a module instance for + //it. + getModule(moduleMap); + + //Transfer any config to this other module. + if (hasProp(config.config, id)) { + config.config[moduleName] = config.config[id]; + } + + try { + req.exec(text); + } catch (e) { + return onError(makeError('fromtexteval', + 'fromText eval for ' + id + + ' failed: ' + e, + e, + [id])); + } + + if (hasInteractive) { + useInteractive = true; + } + + //Mark this as a dependency for the plugin + //resource + this.depMaps.push(moduleMap); + + //Support anonymous modules. + context.completeLoad(moduleName); + + //Bind the value of that module to the value for this + //resource ID. + localRequire([moduleName], load); + }); + + //Use parentName here since the plugin's name is not reliable, + //could be some weird string with no path that actually wants to + //reference the parentName's path. + plugin.load(map.name, localRequire, load, config); + })); + + context.enable(pluginMap, this); + this.pluginMaps[pluginMap.id] = pluginMap; + }, + + enable: function () { + enabledRegistry[this.map.id] = this; + this.enabled = true; + + //Set flag mentioning that the module is enabling, + //so that immediate calls to the defined callbacks + //for dependencies do not trigger inadvertent load + //with the depCount still being zero. + this.enabling = true; + + //Enable each dependency + each(this.depMaps, bind(this, function (depMap, i) { + var id, mod, handler; + + if (typeof depMap === 'string') { + //Dependency needs to be converted to a depMap + //and wired up to this module. + depMap = makeModuleMap(depMap, + (this.map.isDefine ? this.map : this.map.parentMap), + false, + !this.skipMap); + this.depMaps[i] = depMap; + + handler = getOwn(handlers, depMap.id); + + if (handler) { + this.depExports[i] = handler(this); + return; + } + + this.depCount += 1; + + on(depMap, 'defined', bind(this, function (depExports) { + this.defineDep(i, depExports); + this.check(); + })); + + if (this.errback) { + on(depMap, 'error', bind(this, this.errback)); + } + } + + id = depMap.id; + mod = registry[id]; + + //Skip special modules like 'require', 'exports', 'module' + //Also, don't call enable if it is already enabled, + //important in circular dependency cases. + if (!hasProp(handlers, id) && mod && !mod.enabled) { + context.enable(depMap, this); + } + })); + + //Enable each plugin that is used in + //a dependency + eachProp(this.pluginMaps, bind(this, function (pluginMap) { + var mod = getOwn(registry, pluginMap.id); + if (mod && !mod.enabled) { + context.enable(pluginMap, this); + } + })); + + this.enabling = false; + + this.check(); + }, + + on: function (name, cb) { + var cbs = this.events[name]; + if (!cbs) { + cbs = this.events[name] = []; + } + cbs.push(cb); + }, + + emit: function (name, evt) { + each(this.events[name], function (cb) { + cb(evt); + }); + if (name === 'error') { + //Now that the error handler was triggered, remove + //the listeners, since this broken Module instance + //can stay around for a while in the registry. + delete this.events[name]; + } + } + }; + + function callGetModule(args) { + //Skip modules already defined. + if (!hasProp(defined, args[0])) { + getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]); + } + } + + function removeListener(node, func, name, ieName) { + //Favor detachEvent because of IE9 + //issue, see attachEvent/addEventListener comment elsewhere + //in this file. + if (node.detachEvent && !isOpera) { + //Probably IE. If not it will throw an error, which will be + //useful to know. + if (ieName) { + node.detachEvent(ieName, func); + } + } else { + node.removeEventListener(name, func, false); + } + } + + /** + * Given an event from a script node, get the requirejs info from it, + * and then removes the event listeners on the node. + * @param {Event} evt + * @returns {Object} + */ + function getScriptData(evt) { + //Using currentTarget instead of target for Firefox 2.0's sake. Not + //all old browsers will be supported, but this one was easy enough + //to support and still makes sense. + var node = evt.currentTarget || evt.srcElement; + + //Remove the listeners once here. + removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange'); + removeListener(node, context.onScriptError, 'error'); + + return { + node: node, + id: node && node.getAttribute('data-requiremodule') + }; + } + + function intakeDefines() { + var args; + + //Any defined modules in the global queue, intake them now. + takeGlobalQueue(); + + //Make sure any remaining defQueue items get properly processed. + while (defQueue.length) { + args = defQueue.shift(); + if (args[0] === null) { + return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1])); + } else { + //args are id, deps, factory. Should be normalized by the + //define() function. + callGetModule(args); + } + } + } + + context = { + config: config, + contextName: contextName, + registry: registry, + defined: defined, + urlFetched: urlFetched, + defQueue: defQueue, + Module: Module, + makeModuleMap: makeModuleMap, + nextTick: req.nextTick, + onError: onError, + + /** + * Set a configuration for the context. + * @param {Object} cfg config object to integrate. + */ + configure: function (cfg) { + //Make sure the baseUrl ends in a slash. + if (cfg.baseUrl) { + if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') { + cfg.baseUrl += '/'; + } + } + + //Save off the paths since they require special processing, + //they are additive. + var shim = config.shim, + objs = { + paths: true, + bundles: true, + config: true, + map: true + }; + + eachProp(cfg, function (value, prop) { + if (objs[prop]) { + if (!config[prop]) { + config[prop] = {}; + } + mixin(config[prop], value, true, true); + } else { + config[prop] = value; + } + }); + + //Reverse map the bundles + if (cfg.bundles) { + eachProp(cfg.bundles, function (value, prop) { + each(value, function (v) { + if (v !== prop) { + bundlesMap[v] = prop; + } + }); + }); + } + + //Merge shim + if (cfg.shim) { + eachProp(cfg.shim, function (value, id) { + //Normalize the structure + if (isArray(value)) { + value = { + deps: value + }; + } + if ((value.exports || value.init) && !value.exportsFn) { + value.exportsFn = context.makeShimExports(value); + } + shim[id] = value; + }); + config.shim = shim; + } + + //Adjust packages if necessary. + if (cfg.packages) { + each(cfg.packages, function (pkgObj) { + var location, name; + + pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj; + + name = pkgObj.name; + location = pkgObj.location; + if (location) { + config.paths[name] = pkgObj.location; + } + + //Save pointer to main module ID for pkg name. + //Remove leading dot in main, so main paths are normalized, + //and remove any trailing .js, since different package + //envs have different conventions: some use a module name, + //some use a file name. + config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main') + .replace(currDirRegExp, '') + .replace(jsSuffixRegExp, ''); + }); + } + + //If there are any "waiting to execute" modules in the registry, + //update the maps for them, since their info, like URLs to load, + //may have changed. + eachProp(registry, function (mod, id) { + //If module already has init called, since it is too + //late to modify them, and ignore unnormalized ones + //since they are transient. + if (!mod.inited && !mod.map.unnormalized) { + mod.map = makeModuleMap(id); + } + }); + + //If a deps array or a config callback is specified, then call + //require with those args. This is useful when require is defined as a + //config object before require.js is loaded. + if (cfg.deps || cfg.callback) { + context.require(cfg.deps || [], cfg.callback); + } + }, + + makeShimExports: function (value) { + function fn() { + var ret; + if (value.init) { + ret = value.init.apply(global, arguments); + } + return ret || (value.exports && getGlobal(value.exports)); + } + return fn; + }, + + makeRequire: function (relMap, options) { + options = options || {}; + + function localRequire(deps, callback, errback) { + var id, map, requireMod; + + if (options.enableBuildCallback && callback && isFunction(callback)) { + callback.__requireJsBuild = true; + } + + if (typeof deps === 'string') { + if (isFunction(callback)) { + //Invalid call + return onError(makeError('requireargs', 'Invalid require call'), errback); + } + + //If require|exports|module are requested, get the + //value for them from the special handlers. Caveat: + //this only works while module is being defined. + if (relMap && hasProp(handlers, deps)) { + return handlers[deps](registry[relMap.id]); + } + + //Synchronous access to one module. If require.get is + //available (as in the Node adapter), prefer that. + if (req.get) { + return req.get(context, deps, relMap, localRequire); + } + + //Normalize module name, if it contains . or .. + map = makeModuleMap(deps, relMap, false, true); + id = map.id; + + if (!hasProp(defined, id)) { + return onError(makeError('notloaded', 'Module name "' + + id + + '" has not been loaded yet for context: ' + + contextName + + (relMap ? '' : '. Use require([])'))); + } + return defined[id]; + } + + //Grab defines waiting in the global queue. + intakeDefines(); + + //Mark all the dependencies as needing to be loaded. + context.nextTick(function () { + //Some defines could have been added since the + //require call, collect them. + intakeDefines(); + + requireMod = getModule(makeModuleMap(null, relMap)); + + //Store if map config should be applied to this require + //call for dependencies. + requireMod.skipMap = options.skipMap; + + requireMod.init(deps, callback, errback, { + enabled: true + }); + + checkLoaded(); + }); + + return localRequire; + } + + mixin(localRequire, { + isBrowser: isBrowser, + + /** + * Converts a module name + .extension into an URL path. + * *Requires* the use of a module name. It does not support using + * plain URLs like nameToUrl. + */ + toUrl: function (moduleNamePlusExt) { + var ext, + index = moduleNamePlusExt.lastIndexOf('.'), + segment = moduleNamePlusExt.split('/')[0], + isRelative = segment === '.' || segment === '..'; + + //Have a file extension alias, and it is not the + //dots from a relative path. + if (index !== -1 && (!isRelative || index > 1)) { + ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length); + moduleNamePlusExt = moduleNamePlusExt.substring(0, index); + } + + return context.nameToUrl(normalize(moduleNamePlusExt, + relMap && relMap.id, true), ext, true); + }, + + defined: function (id) { + return hasProp(defined, makeModuleMap(id, relMap, false, true).id); + }, + + specified: function (id) { + id = makeModuleMap(id, relMap, false, true).id; + return hasProp(defined, id) || hasProp(registry, id); + } + }); + + //Only allow undef on top level require calls + if (!relMap) { + localRequire.undef = function (id) { + //Bind any waiting define() calls to this context, + //fix for #408 + takeGlobalQueue(); + + var map = makeModuleMap(id, relMap, true), + mod = getOwn(registry, id); + + removeScript(id); + + delete defined[id]; + delete urlFetched[map.url]; + delete undefEvents[id]; + + //Clean queued defines too. Go backwards + //in array so that the splices do not + //mess up the iteration. + eachReverse(defQueue, function(args, i) { + if(args[0] === id) { + defQueue.splice(i, 1); + } + }); + + if (mod) { + //Hold on to listeners in case the + //module will be attempted to be reloaded + //using a different config. + if (mod.events.defined) { + undefEvents[id] = mod.events; + } + + cleanRegistry(id); + } + }; + } + + return localRequire; + }, + + /** + * Called to enable a module if it is still in the registry + * awaiting enablement. A second arg, parent, the parent module, + * is passed in for context, when this method is overridden by + * the optimizer. Not shown here to keep code compact. + */ + enable: function (depMap) { + var mod = getOwn(registry, depMap.id); + if (mod) { + getModule(depMap).enable(); + } + }, + + /** + * Internal method used by environment adapters to complete a load event. + * A load event could be a script load or just a load pass from a synchronous + * load call. + * @param {String} moduleName the name of the module to potentially complete. + */ + completeLoad: function (moduleName) { + var found, args, mod, + shim = getOwn(config.shim, moduleName) || {}, + shExports = shim.exports; + + takeGlobalQueue(); + + while (defQueue.length) { + args = defQueue.shift(); + if (args[0] === null) { + args[0] = moduleName; + //If already found an anonymous module and bound it + //to this name, then this is some other anon module + //waiting for its completeLoad to fire. + if (found) { + break; + } + found = true; + } else if (args[0] === moduleName) { + //Found matching define call for this script! + found = true; + } + + callGetModule(args); + } + + //Do this after the cycle of callGetModule in case the result + //of those calls/init calls changes the registry. + mod = getOwn(registry, moduleName); + + if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) { + if (config.enforceDefine && (!shExports || !getGlobal(shExports))) { + if (hasPathFallback(moduleName)) { + return; + } else { + return onError(makeError('nodefine', + 'No define call for ' + moduleName, + null, + [moduleName])); + } + } else { + //A script that does not call define(), so just simulate + //the call for it. + callGetModule([moduleName, (shim.deps || []), shim.exportsFn]); + } + } + + checkLoaded(); + }, + + /** + * Converts a module name to a file path. Supports cases where + * moduleName may actually be just an URL. + * Note that it **does not** call normalize on the moduleName, + * it is assumed to have already been normalized. This is an + * internal API, not a public one. Use toUrl for the public API. + */ + nameToUrl: function (moduleName, ext, skipExt) { + var paths, syms, i, parentModule, url, + parentPath, bundleId, + pkgMain = getOwn(config.pkgs, moduleName); + + if (pkgMain) { + moduleName = pkgMain; + } + + bundleId = getOwn(bundlesMap, moduleName); + + if (bundleId) { + return context.nameToUrl(bundleId, ext, skipExt); + } + + //If a colon is in the URL, it indicates a protocol is used and it is just + //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?) + //or ends with .js, then assume the user meant to use an url and not a module id. + //The slash is important for protocol-less URLs as well as full paths. + if (req.jsExtRegExp.test(moduleName)) { + //Just a plain path, not module name lookup, so just return it. + //Add extension if it is included. This is a bit wonky, only non-.js things pass + //an extension, this method probably needs to be reworked. + url = moduleName + (ext || ''); + } else { + //A module that needs to be converted to a path. + paths = config.paths; + + syms = moduleName.split('/'); + //For each module name segment, see if there is a path + //registered for it. Start with most specific name + //and work up from it. + for (i = syms.length; i > 0; i -= 1) { + parentModule = syms.slice(0, i).join('/'); + + parentPath = getOwn(paths, parentModule); + if (parentPath) { + //If an array, it means there are a few choices, + //Choose the one that is desired + if (isArray(parentPath)) { + parentPath = parentPath[0]; + } + syms.splice(0, i, parentPath); + break; + } + } + + //Join the path parts together, then figure out if baseUrl is needed. + url = syms.join('/'); + url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js')); + url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url; + } + + return config.urlArgs ? url + + ((url.indexOf('?') === -1 ? '?' : '&') + + config.urlArgs) : url; + }, + + //Delegates to req.load. Broken out as a separate function to + //allow overriding in the optimizer. + load: function (id, url) { + req.load(context, id, url); + }, + + /** + * Executes a module callback function. Broken out as a separate function + * solely to allow the build system to sequence the files in the built + * layer in the right sequence. + * + * @private + */ + execCb: function (name, callback, args, exports) { + return callback.apply(exports, args); + }, + + /** + * callback for script loads, used to check status of loading. + * + * @param {Event} evt the event from the browser for the script + * that was loaded. + */ + onScriptLoad: function (evt) { + //Using currentTarget instead of target for Firefox 2.0's sake. Not + //all old browsers will be supported, but this one was easy enough + //to support and still makes sense. + if (evt.type === 'load' || + (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) { + //Reset interactive script so a script node is not held onto for + //to long. + interactiveScript = null; + + //Pull out the name of the module and the context. + var data = getScriptData(evt); + context.completeLoad(data.id); + } + }, + + /** + * Callback for script errors. + */ + onScriptError: function (evt) { + var data = getScriptData(evt); + if (!hasPathFallback(data.id)) { + return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id])); + } + } + }; + + context.require = context.makeRequire(); + return context; + } + + /** + * Main entry point. + * + * If the only argument to require is a string, then the module that + * is represented by that string is fetched for the appropriate context. + * + * If the first argument is an array, then it will be treated as an array + * of dependency string names to fetch. An optional function callback can + * be specified to execute when all of those dependencies are available. + * + * Make a local req variable to help Caja compliance (it assumes things + * on a require that are not standardized), and to give a short + * name for minification/local scope use. + */ + req = requirejs = function (deps, callback, errback, optional) { + + //Find the right context, use default + var context, config, + contextName = defContextName; + + // Determine if have config object in the call. + if (!isArray(deps) && typeof deps !== 'string') { + // deps is a config object + config = deps; + if (isArray(callback)) { + // Adjust args if there are dependencies + deps = callback; + callback = errback; + errback = optional; + } else { + deps = []; + } + } + + if (config && config.context) { + contextName = config.context; + } + + context = getOwn(contexts, contextName); + if (!context) { + context = contexts[contextName] = req.s.newContext(contextName); + } + + if (config) { + context.configure(config); + } + + return context.require(deps, callback, errback); + }; + + /** + * Support require.config() to make it easier to cooperate with other + * AMD loaders on globally agreed names. + */ + req.config = function (config) { + return req(config); + }; + + /** + * Execute something after the current tick + * of the event loop. Override for other envs + * that have a better solution than setTimeout. + * @param {Function} fn function to execute later. + */ + req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) { + setTimeout(fn, 4); + } : function (fn) { fn(); }; + + /** + * Export require as a global, but only if it does not already exist. + */ + if (!require) { + require = req; + } + + req.version = version; + + //Used to filter out dependencies that are already paths. + req.jsExtRegExp = /^\/|:|\?|\.js$/; + req.isBrowser = isBrowser; + s = req.s = { + contexts: contexts, + newContext: newContext + }; + + //Create default context. + req({}); + + //Exports some context-sensitive methods on global require. + each([ + 'toUrl', + 'undef', + 'defined', + 'specified' + ], function (prop) { + //Reference from contexts instead of early binding to default context, + //so that during builds, the latest instance of the default context + //with its config gets used. + req[prop] = function () { + var ctx = contexts[defContextName]; + return ctx.require[prop].apply(ctx, arguments); + }; + }); + + if (isBrowser) { + head = s.head = document.getElementsByTagName('head')[0]; + //If BASE tag is in play, using appendChild is a problem for IE6. + //When that browser dies, this can be removed. Details in this jQuery bug: + //http://dev.jquery.com/ticket/2709 + baseElement = document.getElementsByTagName('base')[0]; + if (baseElement) { + head = s.head = baseElement.parentNode; + } + } + + /** + * Any errors that require explicitly generates will be passed to this + * function. Intercept/override it if you want custom error handling. + * @param {Error} err the error object. + */ + req.onError = defaultOnError; + + /** + * Creates the node for the load command. Only used in browser envs. + */ + req.createNode = function (config, moduleName, url) { + var node = config.xhtml ? + document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') : + document.createElement('script'); + node.type = config.scriptType || 'text/javascript'; + node.charset = 'utf-8'; + node.async = true; + return node; + }; + + /** + * Does the request to load a module for the browser case. + * Make this a separate function to allow other environments + * to override it. + * + * @param {Object} context the require context to find state. + * @param {String} moduleName the name of the module. + * @param {Object} url the URL to the module. + */ + req.load = function (context, moduleName, url) { + var config = (context && context.config) || {}, + node; + if (isBrowser) { + //In the browser so use a script tag + node = req.createNode(config, moduleName, url); + + node.setAttribute('data-requirecontext', context.contextName); + node.setAttribute('data-requiremodule', moduleName); + + //Set up load listener. Test attachEvent first because IE9 has + //a subtle issue in its addEventListener and script onload firings + //that do not match the behavior of all other browsers with + //addEventListener support, which fire the onload event for a + //script right after the script execution. See: + //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution + //UNFORTUNATELY Opera implements attachEvent but does not follow the script + //script execution mode. + if (node.attachEvent && + //Check if node.attachEvent is artificially added by custom script or + //natively supported by browser + //read https://github.com/jrburke/requirejs/issues/187 + //if we can NOT find [native code] then it must NOT natively supported. + //in IE8, node.attachEvent does not have toString() + //Note the test for "[native code" with no closing brace, see: + //https://github.com/jrburke/requirejs/issues/273 + !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) && + !isOpera) { + //Probably IE. IE (at least 6-8) do not fire + //script onload right after executing the script, so + //we cannot tie the anonymous define call to a name. + //However, IE reports the script as being in 'interactive' + //readyState at the time of the define call. + useInteractive = true; + + node.attachEvent('onreadystatechange', context.onScriptLoad); + //It would be great to add an error handler here to catch + //404s in IE9+. However, onreadystatechange will fire before + //the error handler, so that does not help. If addEventListener + //is used, then IE will fire error before load, but we cannot + //use that pathway given the connect.microsoft.com issue + //mentioned above about not doing the 'script execute, + //then fire the script load event listener before execute + //next script' that other browsers do. + //Best hope: IE10 fixes the issues, + //and then destroys all installs of IE 6-9. + //node.attachEvent('onerror', context.onScriptError); + } else { + node.addEventListener('load', context.onScriptLoad, false); + node.addEventListener('error', context.onScriptError, false); + } + node.src = url; + + //For some cache cases in IE 6-8, the script executes before the end + //of the appendChild execution, so to tie an anonymous define + //call to the module name (which is stored on the node), hold on + //to a reference to this node, but clear after the DOM insertion. + currentlyAddingScript = node; + if (baseElement) { + head.insertBefore(node, baseElement); + } else { + head.appendChild(node); + } + currentlyAddingScript = null; + + return node; + } else if (isWebWorker) { + try { + //In a web worker, use importScripts. This is not a very + //efficient use of importScripts, importScripts will block until + //its script is downloaded and evaluated. However, if web workers + //are in play, the expectation that a build has been done so that + //only one script needs to be loaded anyway. This may need to be + //reevaluated if other use cases become common. + importScripts(url); + + //Account for anonymous modules + context.completeLoad(moduleName); + } catch (e) { + context.onError(makeError('importscripts', + 'importScripts failed for ' + + moduleName + ' at ' + url, + e, + [moduleName])); + } + } + }; + + function getInteractiveScript() { + if (interactiveScript && interactiveScript.readyState === 'interactive') { + return interactiveScript; + } + + eachReverse(scripts(), function (script) { + if (script.readyState === 'interactive') { + return (interactiveScript = script); + } + }); + return interactiveScript; + } + + //Look for a data-main script attribute, which could also adjust the baseUrl. + if (isBrowser && !cfg.skipDataMain) { + //Figure out baseUrl. Get it from the script tag with require.js in it. + eachReverse(scripts(), function (script) { + //Set the 'head' where we can append children by + //using the script's parent. + if (!head) { + head = script.parentNode; + } + + //Look for a data-main attribute to set main script for the page + //to load. If it is there, the path to data main becomes the + //baseUrl, if it is not already set. + dataMain = script.getAttribute('data-main'); + if (dataMain) { + //Preserve dataMain in case it is a path (i.e. contains '?') + mainScript = dataMain; + + //Set final baseUrl if there is not already an explicit one. + if (!cfg.baseUrl) { + //Pull off the directory of data-main for use as the + //baseUrl. + src = mainScript.split('/'); + mainScript = src.pop(); + subPath = src.length ? src.join('/') + '/' : './'; + + cfg.baseUrl = subPath; + } + + //Strip off any trailing .js since mainScript is now + //like a module name. + mainScript = mainScript.replace(jsSuffixRegExp, ''); + + //If mainScript is still a path, fall back to dataMain + if (req.jsExtRegExp.test(mainScript)) { + mainScript = dataMain; + } + + //Put the data-main script in the files to load. + cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript]; + + return true; + } + }); + } + + /** + * The function that handles definitions of modules. Differs from + * require() in that a string for the module should be the first argument, + * and the function to execute after dependencies are loaded should + * return a value to define the module corresponding to the first argument's + * name. + */ + define = function (name, deps, callback) { + var node, context; + + //Allow for anonymous modules + if (typeof name !== 'string') { + //Adjust args appropriately + callback = deps; + deps = name; + name = null; + } + + //This module may not have dependencies + if (!isArray(deps)) { + callback = deps; + deps = null; + } + + //If no name, and callback is a function, then figure out if it a + //CommonJS thing with dependencies. + if (!deps && isFunction(callback)) { + deps = []; + //Remove comments from the callback string, + //look for require calls, and pull them into the dependencies, + //but only if there are function args. + if (callback.length) { + callback + .toString() + .replace(commentRegExp, '') + .replace(cjsRequireRegExp, function (match, dep) { + deps.push(dep); + }); + + //May be a CommonJS thing even without require calls, but still + //could use exports, and module. Avoid doing exports and module + //work though if it just needs require. + //REQUIRES the function to expect the CommonJS variables in the + //order listed below. + deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps); + } + } + + //If in IE 6-8 and hit an anonymous define() call, do the interactive + //work. + if (useInteractive) { + node = currentlyAddingScript || getInteractiveScript(); + if (node) { + if (!name) { + name = node.getAttribute('data-requiremodule'); + } + context = contexts[node.getAttribute('data-requirecontext')]; + } + } + + //Always save off evaluating the def call until the script onload handler. + //This allows multiple modules to be in a file without prematurely + //tracing dependencies, and allows for anonymous module support, + //where the module name is not known until the script onload event + //occurs. If no context, use the global queue, and get it processed + //in the onscript load callback. + (context ? context.defQueue : globalDefQueue).push([name, deps, callback]); + }; + + define.amd = { + jQuery: true + }; + + + /** + * Executes the text. Normally just uses eval, but can be modified + * to use a better, environment-specific call. Only used for transpiling + * loader plugins, not for plain JS modules. + * @param {String} text the text to execute/evaluate. + */ + req.exec = function (text) { + /*jslint evil: true */ + return eval(text); + }; + + //Set up with config info. + req(cfg); +}(this)); diff --git a/package.json b/package.json index 907fa89c549..d6dabf36605 100644 --- a/package.json +++ b/package.json @@ -63,7 +63,7 @@ "grunt-contrib-concat": "0.1.3", "grunt-contrib-csslint": "0.2.0", "grunt-contrib-jshint": "0.7.1", - "grunt-contrib-qunit": "0.4.0", + "grunt-contrib-qunit": "0.6.0", "grunt-contrib-uglify": "0.1.1", "grunt-esformatter": "0.2.0", "grunt-git-authors": "2.0.0", diff --git a/tests/.jshintrc b/tests/.jshintrc index aeb3150a2eb..e9fbe7ca3d1 100644 --- a/tests/.jshintrc +++ b/tests/.jshintrc @@ -22,6 +22,7 @@ "asyncTest": false, "closeEnough": false, "deepEqual": false, + "define": false, "domEqual": false, "equal": false, "expect": false, diff --git a/tests/lib/bootstrap.js b/tests/lib/bootstrap.js new file mode 100644 index 00000000000..c5e52057eef --- /dev/null +++ b/tests/lib/bootstrap.js @@ -0,0 +1,146 @@ +( function() { + +window.requirejs = { + paths: { + "jquery": jqueryUrl(), + "jquery-simulate": "../../../external/jquery-simulate/jquery.simulate", + "jshint": "../../../external/jshint/jshint", + "lib": "../../lib", + "phantom-bridge": "../../../node_modules/grunt-contrib-qunit/phantomjs/bridge", + "qunit-assert-classes": "../../../external/qunit-assert-classes/qunit-assert-classes", + "qunit": "../../../external/qunit/qunit", + "ui": "../../../ui" + }, + shim: { + "jquery-simulate": [ "jquery" ], + "qunit-assert-classes": [ "qunit" ] + } +}; + +// Load all modules in series +function requireModules( dependencies, callback, modules ) { + if ( !dependencies.length ) { + if ( callback ) { + callback.apply( null, modules ); + } + return; + } + + if ( !modules ) { + modules = []; + } + + var dependency = dependencies.shift(); + require( [ dependency ], function( module ) { + modules.push( module ); + requireModules( dependencies, callback, modules ); + } ); +} + +// Load a set of test file along with the required test infrastructure +function requireTests( dependencies, callback ) { + dependencies = [ + "../../lib/qunit", + "jquery", + "jquery-simulate", + "qunit-assert-classes", + "../../lib/qunit-assert-domequal" + ].concat( dependencies ); + + requireModules( dependencies, function( QUnit ) { + swarmInject(); + QUnit.start(); + } ); +} + +// Parse the URL into key/value pairs +function parseUrl() { + var data = {}; + var parts = document.location.search.slice( 1 ).split( "&" ); + var length = parts.length; + var i = 0; + var current; + + for ( ; i < length; i++ ) { + current = parts[ i ].split( "=" ); + data[ current[ 0 ] ] = current[ 1 ]; + } + + return data; +} + +function jqueryUrl() { + var version = parseUrl().jquery; + var url; + + if ( version === "git" || version === "git1" ) { + url = "http://code.jquery.com/jquery-" + version; + } else { + url = "../../../external/jquery-" + ( version || "1.11.2" ) + "/jquery"; + } + + return url; +}; + +function swarmInject() { + var url = parseUrl().swarmURL; + + if ( !url || url.indexOf( "http" ) !== 0 ) { + return; + } + + document.write( "" ); +} + +// Load test modules based on data attributes +// - data-modules: list of test modules to load +// - data-widget: A widget to load test modules for +// - Automatically loads common, core, events, methods, and options +// - data-deprecated: Loads the deprecated test modules for a widget +(function() { + + // Find the script element + var scripts = document.getElementsByTagName( "script" ); + var script = scripts[ scripts.length - 1 ]; + + // Read the modules + var modules = script.getAttribute( "data-modules" ); + if ( modules ) { + modules = modules + .replace( /^\s+|\s+$/g, "" ) + .split( /\s+/ ); + } else { + modules = []; + } + var widget = script.getAttribute( "data-widget" ); + var deprecated = script.getAttribute( "data-deprecated" ); + if ( widget ) { + modules = modules.concat([ + widget + ( deprecated ? "_common_deprecated" : "_common" ), + widget + "_core", + widget + "_events", + widget + "_methods", + widget + "_options" + ]); + if ( deprecated ) { + modules = modules.concat( widget + "_deprecated" ); + } + } + + // Load requirejs, then load the tests + script = document.createElement( "script" ); + script.src = "../../../external/requirejs/require.js"; + script.onload = function() { + + // Create a dummy bridge if we're not actually testing in PhantomJS + if ( !/PhantomJS/.test( navigator.userAgent ) ) { + define( "phantom-bridge", function() {} ); + } + + requireTests( modules ); + }; + document.documentElement.appendChild( script ); +} )(); + +} )(); diff --git a/tests/lib/common.js b/tests/lib/common.js new file mode 100644 index 00000000000..9faa4e246b1 --- /dev/null +++ b/tests/lib/common.js @@ -0,0 +1,133 @@ +define([ + "jquery" +], function( $ ) { + +var exports = {}; + +function testWidgetDefaults( widget, defaults ) { + var pluginDefaults = $.ui[ widget ].prototype.options; + + // Ensure that all defaults have the correct value + test( "defined defaults", function() { + var count = 0; + $.each( defaults, function( key, val ) { + expect( ++count ); + if ( $.isFunction( val ) ) { + ok( $.isFunction( pluginDefaults[ key ] ), key ); + return; + } + deepEqual( pluginDefaults[ key ], val, key ); + }); + }); + + // Ensure that all defaults were tested + test( "tested defaults", function() { + var count = 0; + $.each( pluginDefaults, function( key ) { + expect( ++count ); + ok( key in defaults, key ); + }); + }); +} + +function testWidgetOverrides( widget ) { + if ( $.uiBackCompat === false ) { + test( "$.widget overrides", function() { + expect( 4 ); + $.each([ + "_createWidget", + "destroy", + "option", + "_trigger" + ], function( i, method ) { + strictEqual( $.ui[ widget ].prototype[ method ], + $.Widget.prototype[ method ], "should not override " + method ); + }); + }); + } +} + +function testBasicUsage( widget ) { + test( "basic usage", function() { + expect( 3 ); + + var defaultElement = $.ui[ widget ].prototype.defaultElement; + $( defaultElement ).appendTo( "body" )[ widget ]().remove(); + ok( true, "initialized on element" ); + + $( defaultElement )[ widget ]().remove(); + ok( true, "initialized on disconnected DOMElement - never connected" ); + + // Ensure manipulating removed elements works (#3664) + $( defaultElement ).appendTo( "body" ).remove()[ widget ]().remove(); + ok( true, "initialized on disconnected DOMElement - removed" ); + }); +} + +exports.testWidget = function( widget, settings ) { + module( widget + ": common widget" ); + + exports.testJshint( widget ); + testWidgetDefaults( widget, settings.defaults ); + testWidgetOverrides( widget ); + testBasicUsage( widget ); + test( "version", function() { + expect( 1 ); + ok( "version" in $.ui[ widget ].prototype, "version property exists" ); + }); +}; + +exports.testJshint = function( module ) { + + // Function.prototype.bind check is needed because JSHint doesn't work in ES3 browsers anymore + // https://github.com/jshint/jshint/issues/1384 + if ( QUnit.urlParams.nojshint || !Function.prototype.bind ) { + return; + } + + asyncTest( "JSHint", function() { + require( [ "jshint" ], function() { + expect( 1 ); + + $.when( + $.ajax( { + url: "../../../ui/.jshintrc", + dataType: "json" + } ), + $.ajax( { + url: "../../../ui/" + module + ".js", + dataType: "text" + } ) + ) + .done( function( hintArgs, srcArgs ) { + var globals, passed, errors, + jshintrc = hintArgs[ 0 ], + source = srcArgs[ 0 ]; + + globals = jshintrc.globals || {}; + delete jshintrc.globals; + passed = JSHINT( source, jshintrc, globals ); + errors = $.map( JSHINT.errors, function( error ) { + + // JSHINT may report null if there are too many errors + if ( !error ) { + return; + } + + return "[L" + error.line + ":C" + error.character + "] " + + error.reason + "\n" + error.evidence + "\n"; + } ).join( "\n" ); + ok( passed, errors ); + start(); + } ) + .fail(function( hintError, srcError ) { + ok( false, "error loading source: " + ( hintError || srcError ).statusText ); + start(); + } ); + }); + }); +}; + +return exports; + +}); diff --git a/tests/lib/css.js b/tests/lib/css.js new file mode 100644 index 00000000000..37353e912ef --- /dev/null +++ b/tests/lib/css.js @@ -0,0 +1,23 @@ +(function() { + +function includeStyle( url ) { + document.write( "" ); +} + +// Find the script element +var scripts = document.getElementsByTagName( "script" ); +var script = scripts[ scripts.length - 1 ]; + +// Load the modules +var modules = script.getAttribute( "data-modules" ); +if ( modules ) { + modules = modules.split( /\s+/ ); + for ( var i = 0; i < modules.length; i++ ) { + includeStyle( "themes/base/" + modules[ i ] + ".css" ); + } +} + +// Load the QUnit stylesheet +includeStyle( "external/qunit/qunit.css" ); + +} )(); diff --git a/tests/lib/helper.js b/tests/lib/helper.js new file mode 100644 index 00000000000..80cb27274fc --- /dev/null +++ b/tests/lib/helper.js @@ -0,0 +1,33 @@ +define([ + "jquery" +], function( $ ) { + +var exports = {}; + +exports.forceScrollableWindow = function( appendTo ) { + + // The main testable area is 10000x10000 so to enforce scrolling, + // this DIV must be greater than 10000 to work + return $( "
" ) + .css({ + height: "11000px", + width: "11000px" + }) + .appendTo( appendTo || "#qunit-fixture" ); +}; + +exports.onFocus = function( element, onFocus ) { + var fn = function( event ) { + if ( !event.originalEvent ) { + return; + } + element.unbind( "focus", fn ); + onFocus(); + }; + + element.bind( "focus", fn )[ 0 ].focus(); +}; + +return exports; + +}); diff --git a/tests/lib/qunit-assert-domequal.js b/tests/lib/qunit-assert-domequal.js new file mode 100644 index 00000000000..49c8f6714f4 --- /dev/null +++ b/tests/lib/qunit-assert-domequal.js @@ -0,0 +1,122 @@ +/* + * Experimental assertion for comparing DOM objects. + * + * Serializes an element and some properties and attributes and its children if any, + * otherwise the text. Then compares the result using deepEqual(). + */ +define( [ + "qunit", + "jquery" +], function( QUnit, $ ) { + +var domEqual = QUnit.assert.domEqual = function( selector, modifier, message ) { + + var assert = this; + + // Get current state prior to modifier + var expected = extract( $( selector ) ); + + function done() { + var actual = extract( $( selector ) ); + assert.push( QUnit.equiv( actual, expected ), actual, expected, message ); + } + + // Run modifier (async or sync), then compare state via done() + if ( modifier.length ) { + modifier( done ); + } else { + modifier(); + done(); + } +}; + +domEqual.properties = [ + "disabled", + "readOnly" +]; + +domEqual.attributes = [ + "autocomplete", + "aria-activedescendant", + "aria-controls", + "aria-describedby", + "aria-disabled", + "aria-expanded", + "aria-haspopup", + "aria-hidden", + "aria-labelledby", + "aria-pressed", + "aria-selected", + "aria-valuemax", + "aria-valuemin", + "aria-valuenow", + "class", + "href", + "id", + "nodeName", + "role", + "tabIndex", + "title" +]; + +function getElementStyles( elem ) { + var styles = {}; + var style = elem.ownerDocument.defaultView ? + elem.ownerDocument.defaultView.getComputedStyle( elem, null ) : + elem.currentStyle; + var key, len; + + if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) { + len = style.length; + while ( len-- ) { + key = style[ len ]; + if ( typeof style[ key ] === "string" ) { + styles[ $.camelCase( key ) ] = style[ key ]; + } + } + + // Support: Opera, IE <9 + } else { + for ( key in style ) { + if ( typeof style[ key ] === "string" ) { + styles[ key ] = style[ key ]; + } + } + } + + return styles; +} + +function extract( elem ) { + if ( !elem || !elem.length ) { + QUnit.push( false, actual, expected, + "domEqual failed, can't extract " + selector + ", message was: " + message ); + return; + } + + var result = {}; + var children; + $.each( domEqual.properties, function( index, attr ) { + var value = elem.prop( attr ); + result[ attr ] = value != null ? value : ""; + }); + $.each( domEqual.attributes, function( index, attr ) { + var value = elem.attr( attr ); + result[ attr ] = value != null ? value : ""; + }); + result.style = getElementStyles( elem[ 0 ] ); + result.events = $._data( elem[ 0 ], "events" ); + result.data = $.extend( {}, elem.data() ); + delete result.data[ $.expando ]; + children = elem.children(); + if ( children.length ) { + result.children = elem.children().map(function() { + return extract( $( this ) ); + }).get(); + } else { + result.text = elem.text(); + } + return result; +} + +} ); diff --git a/tests/lib/qunit.js b/tests/lib/qunit.js new file mode 100644 index 00000000000..fc119a47d50 --- /dev/null +++ b/tests/lib/qunit.js @@ -0,0 +1,45 @@ +define( [ + "qunit", + "jquery", + "phantom-bridge" +], function( QUnit, $ ) { + +QUnit.config.autostart = false; +QUnit.config.requireExpects = true; + +QUnit.config.urlConfig.push({ + id: "nojshint", + label: "Skip JSHint", + tooltip: "Skip running JSHint, e.g., within TestSwarm, where Jenkins runs it already" +}); + +QUnit.config.urlConfig.push({ + id: "jquery", + label: "jQuery version", + value: [ + "1.7.0", "1.7.1", "1.7.2", + "1.8.0", "1.8.1", "1.8.2", "1.8.3", + "1.9.0", "1.9.1", + "1.10.0", "1.10.1", "1.10.2", + "1.11.0", "1.11.1", "1.11.2", + "2.0.0", "2.0.1", "2.0.2", "2.0.3", + "2.1.0", "2.1.1", "2.1.2", "2.1.3", + "git1", "git" + ], + tooltip: "Which jQuery Core version to test against" +}); + +QUnit.reset = ( function( reset ) { + return function() { + + // Ensure jQuery events and data on the fixture are properly removed + $( "#qunit-fixture" ).empty(); + + // Let QUnit reset the fixture + reset.apply( this, arguments ); + }; +} )( QUnit.reset ); + +return QUnit; + +} ); From 3a3d46e3809eeda985dd81c67c3da5184aa74cdc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Tue, 31 Mar 2015 16:52:28 -0400 Subject: [PATCH 02/29] Tests: Convert closeEnough() to a proper QUnit assertion Should eventually replace with qunit-assert-close. --- tests/.jshintrc | 1 - tests/lib/qunit.js | 6 +++ tests/unit/dialog/dialog_options.js | 62 +++++++++++------------ tests/unit/draggable/draggable_core.js | 16 +++--- tests/unit/draggable/draggable_options.js | 28 +++++----- tests/unit/effects/effects_scale.js | 6 +-- tests/unit/testsuite.js | 4 +- 7 files changed, 64 insertions(+), 59 deletions(-) diff --git a/tests/.jshintrc b/tests/.jshintrc index e9fbe7ca3d1..d4665d6b66d 100644 --- a/tests/.jshintrc +++ b/tests/.jshintrc @@ -20,7 +20,6 @@ "globals": { "asyncTest": false, - "closeEnough": false, "deepEqual": false, "define": false, "domEqual": false, diff --git a/tests/lib/qunit.js b/tests/lib/qunit.js index fc119a47d50..5b0be5d2393 100644 --- a/tests/lib/qunit.js +++ b/tests/lib/qunit.js @@ -40,6 +40,12 @@ QUnit.reset = ( function( reset ) { }; } )( QUnit.reset ); +// TODO: switch to qunit-assert-close plugin +QUnit.assert.close = function( actual, expected, maxDifference, message ) { + var passes = ( actual === expected ) || Math.abs( actual - expected ) <= maxDifference; + QUnit.push( passes, actual, expected, message ); +}; + return QUnit; } ); diff --git a/tests/unit/dialog/dialog_options.js b/tests/unit/dialog/dialog_options.js index 6cc309ca457..1c3648f111d 100644 --- a/tests/unit/dialog/dialog_options.js +++ b/tests/unit/dialog/dialog_options.js @@ -262,83 +262,83 @@ test("height", function() { element.remove(); }); -test("maxHeight", function() { +test("maxHeight", function( assert ) { expect(3); var element = $("
").dialog({ maxHeight: 200 }); TestHelpers.dialog.drag(element, ".ui-resizable-s", 1000, 1000); - closeEnough(element.dialog("widget").height(), 200, 1, "maxHeight"); + assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }); TestHelpers.dialog.drag(element, ".ui-resizable-n", -1000, -1000); - closeEnough(element.dialog("widget").height(), 200, 1, "maxHeight"); + assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }).dialog("option", "maxHeight", 300); TestHelpers.dialog.drag(element, ".ui-resizable-s", 1000, 1000); - closeEnough(element.dialog("widget").height(), 300, 1, "maxHeight"); + assert.close(element.dialog("widget").height(), 300, 1, "maxHeight"); element.remove(); }); -test("maxWidth", function() { +test("maxWidth", function( assert ) { expect(3); var element = $("
").dialog({ maxWidth: 200 }); TestHelpers.dialog.drag(element, ".ui-resizable-e", 1000, 1000); - closeEnough(element.dialog("widget").width(), 200, 1, "maxWidth"); + assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }); TestHelpers.dialog.drag(element, ".ui-resizable-w", -1000, -1000); - closeEnough(element.dialog("widget").width(), 200, 1, "maxWidth"); + assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }).dialog("option", "maxWidth", 300); TestHelpers.dialog.drag(element, ".ui-resizable-w", -1000, -1000); - closeEnough(element.dialog("widget").width(), 300, 1, "maxWidth"); + assert.close(element.dialog("widget").width(), 300, 1, "maxWidth"); element.remove(); }); -test("minHeight", function() { +test("minHeight", function( assert ) { expect(3); var element = $("
").dialog({ minHeight: 10 }); TestHelpers.dialog.drag(element, ".ui-resizable-s", -1000, -1000); - closeEnough(element.dialog("widget").height(), 10, 1, "minHeight"); + assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }); TestHelpers.dialog.drag(element, ".ui-resizable-n", 1000, 1000); - closeEnough(element.dialog("widget").height(), 10, 1, "minHeight"); + assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }).dialog("option", "minHeight", 30); TestHelpers.dialog.drag(element, ".ui-resizable-n", 1000, 1000); - closeEnough(element.dialog("widget").height(), 30, 1, "minHeight"); + assert.close(element.dialog("widget").height(), 30, 1, "minHeight"); element.remove(); }); -test("minWidth", function() { +test("minWidth", function( assert ) { expect(3); var element = $("
").dialog({ minWidth: 10 }); TestHelpers.dialog.drag(element, ".ui-resizable-e", -1000, -1000); - closeEnough(element.dialog("widget").width(), 10, 1, "minWidth"); + assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 10 }); TestHelpers.dialog.drag(element, ".ui-resizable-w", 1000, 1000); - closeEnough(element.dialog("widget").width(), 10, 1, "minWidth"); + assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 30 }).dialog("option", "minWidth", 30); TestHelpers.dialog.drag(element, ".ui-resizable-w", 1000, 1000); - closeEnough(element.dialog("widget").width(), 30, 1, "minWidth"); + assert.close(element.dialog("widget").width(), 30, 1, "minWidth"); element.remove(); }); -test( "position, default center on window", function() { +test( "position, default center on window", function( assert ) { expect( 2 ); // dialogs alter the window width and height in Firefox @@ -349,12 +349,12 @@ test( "position, default center on window", function() { element = $("
").dialog(), dialog = element.dialog("widget"), offset = dialog.offset(); - closeEnough( offset.left, Math.round( winWidth / 2 - dialog.outerWidth() / 2 ) + $( window ).scrollLeft(), 1, "dialog left position of center on window on initilization" ); - closeEnough( offset.top, Math.round( winHeight / 2 - dialog.outerHeight() / 2 ) + $( window ).scrollTop(), 1, "dialog top position of center on window on initilization" ); + assert.close( offset.left, Math.round( winWidth / 2 - dialog.outerWidth() / 2 ) + $( window ).scrollLeft(), 1, "dialog left position of center on window on initilization" ); + assert.close( offset.top, Math.round( winHeight / 2 - dialog.outerHeight() / 2 ) + $( window ).scrollTop(), 1, "dialog top position of center on window on initilization" ); element.remove(); }); -test( "position, right bottom at right bottom via ui.position args", function() { +test( "position, right bottom at right bottom via ui.position args", function( assert ) { expect( 2 ); // dialogs alter the window width and height in Firefox @@ -371,12 +371,12 @@ test( "position, right bottom at right bottom via ui.position args", function() dialog = element.dialog("widget"), offset = dialog.offset(); - closeEnough( offset.left, winWidth - dialog.outerWidth() + $( window ).scrollLeft(), 1, "dialog left position of right bottom at right bottom on initilization" ); - closeEnough( offset.top, winHeight - dialog.outerHeight() + $( window ).scrollTop(), 1, "dialog top position of right bottom at right bottom on initilization" ); + assert.close( offset.left, winWidth - dialog.outerWidth() + $( window ).scrollLeft(), 1, "dialog left position of right bottom at right bottom on initilization" ); + assert.close( offset.top, winHeight - dialog.outerHeight() + $( window ).scrollTop(), 1, "dialog top position of right bottom at right bottom on initilization" ); element.remove(); }); -test( "position, at another element", function() { +test( "position, at another element", function( assert ) { expect( 4 ); var parent = $("
").css({ position: "absolute", @@ -398,8 +398,8 @@ test( "position, at another element", function() { dialog = element.dialog("widget"), offset = dialog.offset(); - closeEnough( offset.left, 600, 1, "dialog left position at another element on initilization" ); - closeEnough( offset.top, 400, 1, "dialog top position at another element on initilization" ); + assert.close( offset.left, 600, 1, "dialog left position at another element on initilization" ); + assert.close( offset.top, 400, 1, "dialog top position at another element on initilization" ); element.dialog("option", "position", { my: "left top", @@ -410,8 +410,8 @@ test( "position, at another element", function() { offset = dialog.offset(); - closeEnough( offset.left, 610, 1, "dialog left position at another element via setting option" ); - closeEnough( offset.top, 410, 1, "dialog top position at another element via setting option" ); + assert.close( offset.left, 610, 1, "dialog left position at another element via setting option" ); + assert.close( offset.top, 410, 1, "dialog top position at another element via setting option" ); element.remove(); parent.remove(); @@ -475,17 +475,17 @@ test( "title", function() { element.remove(); }); -test("width", function() { +test("width", function( assert ) { expect(3); var element = $("
").dialog(); - closeEnough(element.dialog("widget").width(), 300, 1, "default width"); + assert.close(element.dialog("widget").width(), 300, 1, "default width"); element.remove(); element = $("
").dialog({width: 437 }); - closeEnough(element.dialog("widget").width(), 437, 1, "explicit width"); + assert.close(element.dialog("widget").width(), 437, 1, "explicit width"); element.dialog("option", "width", 438); - closeEnough(element.dialog("widget").width(), 438, 1, "explicit width after init"); + assert.close(element.dialog("widget").width(), 438, 1, "explicit width after init"); element.remove(); }); diff --git a/tests/unit/draggable/draggable_core.js b/tests/unit/draggable/draggable_core.js index 8b389516360..3351334ef40 100644 --- a/tests/unit/draggable/draggable_core.js +++ b/tests/unit/draggable/draggable_core.js @@ -6,7 +6,7 @@ module( "draggable: core" ); -test( "element types", function() { +test( "element types", function( assert ) { var typeNames = ( "p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form" + ",table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr" + @@ -42,8 +42,8 @@ test( "element types", function() { // Support: FF, Chrome, and IE9, // there are some rounding errors in so we can't say equal, we have to settle for close enough - closeEnough( offsetBefore.left, offsetAfter.left - 50, 1, "dragged[50, 50] " + "<" + typeName + "> left" ); - closeEnough( offsetBefore.top, offsetAfter.top - 50, 1, "dragged[50, 50] " + "<" + typeName + "> top" ); + assert.close( offsetBefore.left, offsetAfter.left - 50, 1, "dragged[50, 50] " + "<" + typeName + "> left" ); + assert.close( offsetBefore.top, offsetAfter.top - 50, 1, "dragged[50, 50] " + "<" + typeName + "> top" ); el.draggable("destroy"); el.remove(); }); @@ -350,7 +350,7 @@ test( "ui-draggable-handle managed correctly in nested draggables", function( as // http://bugs.jqueryui.com/ticket/7772 // when css 'right' is set, element resizes on drag -test( "setting right/bottom css shouldn't cause resize", function() { +test( "setting right/bottom css shouldn't cause resize", function( assert ) { expect( 4 ); var finalOffset, @@ -367,10 +367,10 @@ test( "setting right/bottom css shouldn't cause resize", function() { finalOffset.left += 50; finalOffset.top += 50; - closeEnough( element.width(), origWidth, 1, "element retains width" ); - closeEnough( element.height(), origHeight, 1, "element retains height" ); - closeEnough( finalOffset.top, origOffset.top, "element moves the correct vertical distance" ); - closeEnough( finalOffset.top, origOffset.top, "element moves the correct horizontal distance" ); + assert.close( element.width(), origWidth, 1, "element retains width" ); + assert.close( element.height(), origHeight, 1, "element retains height" ); + assert.close( finalOffset.top, origOffset.top, "element moves the correct vertical distance" ); + assert.close( finalOffset.top, origOffset.top, "element moves the correct horizontal distance" ); }); })( jQuery ); diff --git a/tests/unit/draggable/draggable_options.js b/tests/unit/draggable/draggable_options.js index d8bbedc9163..0d495713676 100644 --- a/tests/unit/draggable/draggable_options.js +++ b/tests/unit/draggable/draggable_options.js @@ -519,7 +519,7 @@ test( "{ containment: 'parent' }, absolute", function() { deepEqual( offsetAfter, expected, "compare offset to parent" ); }); -test( "containment, account for border", function() { +test( "containment, account for border", function( assert ) { expect( 2 ); var el = $( "#draggable1" ).appendTo( "#scrollParent" ), @@ -544,9 +544,9 @@ test( "containment, account for border", function() { dy: 100 }); - closeEnough( el.offset().top, parentBottom - parentBorderBottom - el.height(), 1, + assert.close( el.offset().top, parentBottom - parentBorderBottom - el.height(), 1, "The draggable should be on top of its parent's bottom border" ); - closeEnough( el.offset().left, parentRight - parentBorderRight - el.width(), 1, + assert.close( el.offset().left, parentRight - parentBorderRight - el.width(), 1, "The draggable should be to the right of its parent's right border" ); }); @@ -1137,7 +1137,7 @@ test( "scroll ignores containers that are overflow: hidden", function() { equal( scrollParent.scrollLeft(), 0, "container doesn't scroll horizontally" ); }); -test( "#6817: auto scroll goes double distance when dragging", function() { +test( "#6817: auto scroll goes double distance when dragging", function( assert ) { expect( 2 ); TestHelpers.draggable.restoreScroll( document ); @@ -1149,8 +1149,8 @@ test( "#6817: auto scroll goes double distance when dragging", function() { scroll: true, stop: function( e, ui ) { equal( ui.offset.top, newY, "offset of item matches pointer position after scroll" ); - // TODO: fix IE8 testswarm IFRAME positioning bug so closeEnough can be turned back to equal - closeEnough( ui.offset.top - offsetBefore.top, distance, 1, "offset of item only moves expected distance after scroll" ); + // TODO: fix IE8 testswarm IFRAME positioning bug so assert.close can be turned back to equal + assert.close( ui.offset.top - offsetBefore.top, distance, 1, "offset of item only moves expected distance after scroll" ); } }), scrollSensitivity = element.draggable( "option", "scrollSensitivity" ), @@ -1174,7 +1174,7 @@ test( "#6817: auto scroll goes double distance when dragging", function() { TestHelpers.draggable.restoreScroll( document ); }); -test( "snap, snapMode, and snapTolerance", function() { +test( "snap, snapMode, and snapTolerance", function( assert ) { expect( 10 ); var newX, newY, @@ -1206,9 +1206,9 @@ test( "snap, snapMode, and snapTolerance", function() { moves: 1 }); - // TODO: fix IE8 testswarm IFRAME positioning bug so closeEnough can be turned back to equal - closeEnough( element.offset().left, newX, 1, "doesn't snap outside the snapTolerance" ); - closeEnough( element.offset().top, newY, 1, "doesn't snap outside the snapTolerance" ); + // TODO: fix IE8 testswarm IFRAME positioning bug so assert.close can be turned back to equal + assert.close( element.offset().left, newX, 1, "doesn't snap outside the snapTolerance" ); + assert.close( element.offset().top, newY, 1, "doesn't snap outside the snapTolerance" ); newX += 3; @@ -1301,7 +1301,7 @@ test( "snap, snapMode, and snapTolerance", function() { deepEqual( element.offset(), { top: newY, left: newX }, "doesn't snap on the inner snapTolerance area when snapMode is outer" ); }); -test( "#8459: element can snap to an element that was removed during drag", function() { +test( "#8459: element can snap to an element that was removed during drag", function( assert ) { expect( 2 ); var newX, newY, @@ -1337,9 +1337,9 @@ test( "#8459: element can snap to an element that was removed during drag", func ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { - // TODO: fix IE8 testswarm IFRAME positioning bug so closeEnough can be turned back to equal - closeEnough( element.offset().left, newX, 1, "doesn't snap to a removed element" ); - closeEnough( element.offset().top, newY, 1, "doesn't snap to a removed element" ); + // TODO: fix IE8 testswarm IFRAME positioning bug so assert.close can be turned back to equal + assert.close( element.offset().left, newX, 1, "doesn't snap to a removed element" ); + assert.close( element.offset().top, newY, 1, "doesn't snap to a removed element" ); } }); diff --git a/tests/unit/effects/effects_scale.js b/tests/unit/effects/effects_scale.js index caed39c228c..03446367dc3 100644 --- a/tests/unit/effects/effects_scale.js +++ b/tests/unit/effects/effects_scale.js @@ -3,11 +3,11 @@ module( "effect.scale: Scale" ); function run( position, v, h, vo, ho ) { var desc = "End Position Correct: " + position + " (" + v + "," + h + ") - origin: (" + vo + "," + ho + ")"; - asyncTest( desc, function() { + asyncTest( desc, function( assert ) { expect( 2 ); function complete() { - closeEnough( parseInt( test.css( h ), 10 ), target[ h ], 1, "Horizontal Position Correct " + desc ); - closeEnough( parseInt( test.css( v ), 10 ), target[ v ], 1, "Vertical Position Correct " + desc ); + assert.close( parseInt( test.css( h ), 10 ), target[ h ], 1, "Horizontal Position Correct " + desc ); + assert.close( parseInt( test.css( v ), 10 ), target[ v ], 1, "Vertical Position Correct " + desc ); start(); } var test = $( ".testScale" ), diff --git a/tests/unit/testsuite.js b/tests/unit/testsuite.js index e03fd8f67a8..59e40af43e5 100644 --- a/tests/unit/testsuite.js +++ b/tests/unit/testsuite.js @@ -224,8 +224,8 @@ TestHelpers.forceScrollableWindow = function( appendTo ) { }).appendTo( appendTo || "#qunit-fixture" ); }; -// Taken from https://github.com/jquery/qunit/tree/master/addons/close-enough -window.closeEnough = function( actual, expected, maxDifference, message ) { +// TODO: switch to qunit-assert-close plugin +QUnit.assert.close = function( actual, expected, maxDifference, message ) { var passes = ( actual === expected ) || Math.abs( actual - expected ) <= maxDifference; QUnit.push( passes, actual, expected, message ); }; From 1ce65bd9c3f9dc789c7f8fa2ab37a8e900b91f5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Fri, 3 Apr 2015 15:24:09 -0400 Subject: [PATCH 03/29] Accordion: Convert tests to new infrastructure --- tests/unit/accordion/accordion.html | 27 ++----------------- tests/unit/accordion/accordion_common.js | 9 ++++++- tests/unit/accordion/accordion_core.js | 12 ++++++--- tests/unit/accordion/accordion_events.js | 12 ++++++--- tests/unit/accordion/accordion_methods.js | 18 ++++++++----- tests/unit/accordion/accordion_options.js | 14 ++++++---- .../unit/accordion/accordion_test_helpers.js | 11 +++++--- 7 files changed, 54 insertions(+), 49 deletions(-) diff --git a/tests/unit/accordion/accordion.html b/tests/unit/accordion/accordion.html index 9ea2d364539..db206a2e597 100644 --- a/tests/unit/accordion/accordion.html +++ b/tests/unit/accordion/accordion.html @@ -4,31 +4,8 @@ jQuery UI Accordion Test Suite - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - diff --git a/tests/unit/draggable/draggable_common.js b/tests/unit/draggable/draggable_common.js index 6a70cd7d436..7ae032c0f3e 100644 --- a/tests/unit/draggable/draggable_common.js +++ b/tests/unit/draggable/draggable_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "draggable", { +define( [ + "lib/common", + "ui/draggable" +], function( common ) { + +common.testWidget( "draggable", { defaults: { appendTo: "parent", axis: false, @@ -39,3 +44,5 @@ TestHelpers.commonWidgetTests( "draggable", { stop: null } }); + +} ); diff --git a/tests/unit/draggable/draggable_core.js b/tests/unit/draggable/draggable_core.js index 3351334ef40..d484b776d37 100644 --- a/tests/unit/draggable/draggable_core.js +++ b/tests/unit/draggable/draggable_core.js @@ -1,8 +1,11 @@ -/* - * draggable_core.js - */ - -(function( $ ) { +define( [ + "jquery", + "lib/helper", + "./draggable_test_helpers", + "ui/draggable", + "ui/droppable", + "ui/resizable" +], function( $, testHelpers, draggableTestHelpers ) { module( "draggable: core" ); @@ -51,12 +54,12 @@ test( "element types", function( assert ) { test( "No options, relative", function() { expect( 2 ); - TestHelpers.draggable.shouldMove( $( "#draggable1" ).draggable(), "no options, relative" ); + draggableTestHelpers.shouldMove( $( "#draggable1" ).draggable(), "no options, relative" ); }); test( "No options, absolute", function() { expect( 2 ); - TestHelpers.draggable.shouldMove( $( "#draggable2" ).draggable(), "no options, absolute" ); + draggableTestHelpers.shouldMove( $( "#draggable2" ).draggable(), "no options, absolute" ); }); test( "resizable handle with complex markup (#8756 / #8757)", function() { @@ -99,7 +102,7 @@ test( "#8269: Removing draggable element on drop", function() { }); // Support: Opera 12.10, Safari 5.1, jQuery <1.8 - if ( TestHelpers.draggable.unreliableContains ) { + if ( draggableTestHelpers.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -125,7 +128,7 @@ test( "Stray mousemove after mousedown still drags", function() { $( document ).simulate( "mousemove", { button: -1 }); }); - TestHelpers.draggable.shouldMove( element, "element is draggable" ); + draggableTestHelpers.shouldMove( element, "element is draggable" ); }); test( "#6258: not following mouse when scrolled and using overflow-y: scroll", function() { @@ -145,7 +148,7 @@ test( "#6258: not following mouse when scrolled and using overflow-y: scroll", f oldOverflowY = $( "html" ).css( "overflow-y" ), oldOverflowX = $( "html" ).css( "overflow-x" ); - TestHelpers.forceScrollableWindow(); + testHelpers.forceScrollableWindow(); $( "html" ) .css( "overflow-y", "scroll" ) @@ -171,7 +174,7 @@ test( "#9315: jumps down with offset of scrollbar", function() { } }); - TestHelpers.forceScrollableWindow(); + testHelpers.forceScrollableWindow(); $( "html" ).scrollTop( 300 ).scrollLeft( 300 ); @@ -205,7 +208,7 @@ test( "scroll offset with fixed ancestors", function() { } }); - TestHelpers.forceScrollableWindow(); + testHelpers.forceScrollableWindow(); $( "#wrapper" ).css( "position", "fixed" ); $( "#wrapper2" ).css( "position", "absolute" ); @@ -276,8 +279,8 @@ test( "#5727: draggable from iframe", function() { equal( draggable1.closest( iframeBody ).length, 1 ); // TODO: fix draggable within an IFRAME to fire events on the element properly - // and these TestHelpers.draggable.shouldMove relies on events for testing - //TestHelpers.draggable.shouldMove( draggable1, "draggable from an iframe" ); + // and these draggableTestHelpers.shouldMove relies on events for testing + //draggableTestHelpers.shouldMove( draggable1, "draggable from an iframe" ); }); test( "#8399: A draggable should become the active element after you are finished interacting with it, but not before.", function() { @@ -289,7 +292,7 @@ test( "#8399: A draggable should become the active element after you are finishe notStrictEqual( document.activeElement, element.get( 0 ), "moving a draggable anchor did not make it the active element" ); }); - TestHelpers.draggable.move( element, 50, 50 ); + draggableTestHelpers.move( element, 50, 50 ); strictEqual( document.activeElement, element.get( 0 ), "finishing moving a draggable anchor made it the active element" ); }); @@ -300,16 +303,16 @@ asyncTest( "blur behavior", function() { var element = $( "#draggable1" ).draggable(), focusElement = $( "
" ).appendTo( element ); - TestHelpers.onFocus( focusElement, function() { + testHelpers.onFocus( focusElement, function() { strictEqual( document.activeElement, focusElement.get( 0 ), "test element is focused before mousing down on a draggable" ); - TestHelpers.draggable.move( focusElement, 1, 1 ); + draggableTestHelpers.move( focusElement, 1, 1 ); // http://bugs.jqueryui.com/ticket/10527 // Draggable: Can't select option in modal dialog (IE8) strictEqual( document.activeElement, focusElement.get( 0 ), "test element is focused after mousing down on itself" ); - TestHelpers.draggable.move( element, 50, 50 ); + draggableTestHelpers.move( element, 50, 50 ); // http://bugs.jqueryui.com/ticket/4261 // active element should blur when mousing down on a draggable @@ -361,7 +364,7 @@ test( "setting right/bottom css shouldn't cause resize", function( assert ) { element.draggable(); - TestHelpers.draggable.move( element, -50, -50 ); + draggableTestHelpers.move( element, -50, -50 ); finalOffset = element.offset(); finalOffset.left += 50; @@ -373,4 +376,4 @@ test( "setting right/bottom css shouldn't cause resize", function( assert ) { assert.close( finalOffset.top, origOffset.top, "element moves the correct horizontal distance" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/draggable/draggable_events.js b/tests/unit/draggable/draggable_events.js index dd5c315b0b4..ebbf606efd0 100644 --- a/tests/unit/draggable/draggable_events.js +++ b/tests/unit/draggable/draggable_events.js @@ -1,7 +1,7 @@ -/* - * draggable_events.js - */ -(function( $ ) { +define( [ + "jquery", + "ui/draggable" +], function( $ ) { var element; @@ -161,4 +161,4 @@ test( "position and offset in hash is consistent between start, drag, and stop", deepEqual( dragOffset, stopOffset, "drag offset equals stop offset" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/draggable/draggable_methods.js b/tests/unit/draggable/draggable_methods.js index 210f48964ed..44e5feb433c 100644 --- a/tests/unit/draggable/draggable_methods.js +++ b/tests/unit/draggable/draggable_methods.js @@ -1,7 +1,8 @@ -/* - * draggable_methods.js - */ -(function( $ ) { +define( [ + "jquery", + "./draggable_test_helpers", + "ui/draggable" +], function( $, draggableTestHelpers ) { var element; @@ -54,19 +55,19 @@ test( "enable", function() { expect( 11 ); element.draggable({ disabled: true }); - TestHelpers.draggable.shouldNotDrag( element, ".draggable({ disabled: true })" ); + draggableTestHelpers.shouldNotDrag( element, ".draggable({ disabled: true })" ); element.draggable("enable"); - TestHelpers.draggable.shouldMove( element, ".draggable('enable')" ); + draggableTestHelpers.shouldMove( element, ".draggable('enable')" ); equal( element.draggable( "option", "disabled" ), false, "disabled option getter" ); element.draggable("destroy"); element.draggable({ disabled: true }); - TestHelpers.draggable.shouldNotDrag( element, ".draggable({ disabled: true })" ); + draggableTestHelpers.shouldNotDrag( element, ".draggable({ disabled: true })" ); element.draggable( "option", "disabled", false ); equal(element.draggable( "option", "disabled" ), false, "disabled option setter" ); - TestHelpers.draggable.shouldMove( element, ".draggable('option', 'disabled', false)" ); + draggableTestHelpers.shouldMove( element, ".draggable('option', 'disabled', false)" ); var expected = element.draggable(), actual = expected.draggable("enable"); @@ -77,19 +78,19 @@ test( "disable", function( assert ) { expect( 14 ); element = $( "#draggable2" ).draggable({ disabled: false }); - TestHelpers.draggable.shouldMove( element, ".draggable({ disabled: false })" ); + draggableTestHelpers.shouldMove( element, ".draggable({ disabled: false })" ); element.draggable( "disable" ); - TestHelpers.draggable.shouldNotDrag( element, ".draggable('disable')" ); + draggableTestHelpers.shouldNotDrag( element, ".draggable('disable')" ); equal( element.draggable( "option", "disabled" ), true, "disabled option getter" ); element.draggable( "destroy" ); element.draggable({ disabled: false }); - TestHelpers.draggable.shouldMove( element, ".draggable({ disabled: false })" ); + draggableTestHelpers.shouldMove( element, ".draggable({ disabled: false })" ); element.draggable( "option", "disabled", true ); equal( element.draggable( "option", "disabled" ), true, "disabled option setter" ); - TestHelpers.draggable.shouldNotDrag( element, ".draggable('option', 'disabled', true)" ); + draggableTestHelpers.shouldNotDrag( element, ".draggable('option', 'disabled', true)" ); assert.lacksClasses( element.draggable( "widget" ), "ui-state-disabled" ); ok( !element.draggable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); @@ -100,4 +101,4 @@ test( "disable", function( assert ) { equal( actual, expected, "disable is chainable" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/draggable/draggable_options.js b/tests/unit/draggable/draggable_options.js index 0d495713676..a67854e9687 100644 --- a/tests/unit/draggable/draggable_options.js +++ b/tests/unit/draggable/draggable_options.js @@ -1,15 +1,19 @@ -(function( $ ) { - -module( "draggable: options" ); +define( [ + "jquery", + "./draggable_test_helpers", + "ui/draggable", + "ui/droppable", + "ui/sortable" +], function( $, draggableTestHelpers ) { // TODO: This doesn't actually test whether append happened, possibly remove test( "{ appendTo: 'parent' }, default, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: "parent" }); - TestHelpers.draggable.shouldMove( element, "absolute appendTo: parent" ); + draggableTestHelpers.shouldMove( element, "absolute appendTo: parent" ); element = $( "#draggable1" ).draggable({ appendTo: "parent" }); - TestHelpers.draggable.shouldMove( element, "relative appendTo: parent" ); + draggableTestHelpers.shouldMove( element, "relative appendTo: parent" ); }); // TODO: This doesn't actually test whether append happened, possibly remove @@ -17,20 +21,20 @@ test( "{ appendTo: Element }, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] }); - TestHelpers.draggable.shouldMove( element, "absolute appendTo: Element" ); + draggableTestHelpers.shouldMove( element, "absolute appendTo: Element" ); element = $( "#draggable1" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] }); - TestHelpers.draggable.shouldMove( element, "relative appendTo: Element" ); + draggableTestHelpers.shouldMove( element, "relative appendTo: Element" ); }); // TODO: This doesn't actually test whether append happened, possibly remove test( "{ appendTo: Selector }, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: "#main" }); - TestHelpers.draggable.shouldMove( element, "absolute appendTo: Selector" ); + draggableTestHelpers.shouldMove( element, "absolute appendTo: Selector" ); element = $( "#draggable1" ).draggable({ appendTo: "#main" }); - TestHelpers.draggable.shouldMove( element, "relative appendTo: Selector" ); + draggableTestHelpers.shouldMove( element, "relative appendTo: Selector" ); }); test( "{ appendTo: 'parent' }, default", function() { @@ -38,11 +42,11 @@ test( "{ appendTo: 'parent' }, default", function() { var element = $( "#draggable1" ).draggable(); - TestHelpers.draggable.trackAppendedParent( element ); + draggableTestHelpers.trackAppendedParent( element ); equal( element.draggable( "option", "appendTo" ), "parent" ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $( "#main" )[ 0 ] ); }); @@ -52,9 +56,9 @@ test( "{ appendTo: Element }", function() { var appendTo = $( "#draggable2" ).parent()[ 0 ], element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - TestHelpers.draggable.trackAppendedParent( element ); + draggableTestHelpers.trackAppendedParent( element ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), appendTo ); }); @@ -64,9 +68,9 @@ test( "{ appendTo: jQuery }", function() { var appendTo = $( "#draggable2" ).parent(), element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - TestHelpers.draggable.trackAppendedParent( element ); + draggableTestHelpers.trackAppendedParent( element ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), appendTo[ 0 ] ); }); @@ -76,9 +80,9 @@ test( "{ appendTo: Selector }", function() { var appendTo = "#main", element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - TestHelpers.draggable.trackAppendedParent( element ); + draggableTestHelpers.trackAppendedParent( element ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $(appendTo)[ 0 ] ); }); @@ -87,34 +91,34 @@ test( "appendTo, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable({ helper: "clone" }); - TestHelpers.draggable.trackAppendedParent( element ); + draggableTestHelpers.trackAppendedParent( element ); // Move and make sure element was appended to fixture - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $( "#main" )[ 0 ] ); // Move and make sure element was appended to main element.draggable( "option", "appendTo", $( "#qunit-fixture" ) ); - TestHelpers.draggable.move( element, 2, 2 ); + draggableTestHelpers.move( element, 2, 2 ); equal( element.data( "last_dragged_parent" ), $( "#qunit-fixture" )[ 0 ] ); }); test( "{ axis: false }, default", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: false }); - TestHelpers.draggable.shouldMove( element, "axis: false" ); + draggableTestHelpers.shouldMove( element, "axis: false" ); }); test( "{ axis: 'x' }", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: "x" }); - TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 0, "axis: x" ); + draggableTestHelpers.testDrag( element, element, 50, 50, 50, 0, "axis: x" ); }); test( "{ axis: 'y' }", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: "y" }); - TestHelpers.draggable.testDrag( element, element, 50, 50, 0, 50, "axis: y" ); + draggableTestHelpers.testDrag( element, element, 50, 50, 0, 50, "axis: y" ); }); test( "{ axis: ? }, unexpected", function() { @@ -132,7 +136,7 @@ test( "{ axis: ? }, unexpected", function() { $.each(unexpected, function(key, val) { element = $( "#draggable2" ).draggable({ axis: val }); - TestHelpers.draggable.shouldMove( element, "axis: " + key ); + draggableTestHelpers.shouldMove( element, "axis: " + key ); element.draggable( "destroy" ); }); }); @@ -143,15 +147,15 @@ test( "axis, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable({ axis: false }); // Any Direction - TestHelpers.draggable.shouldMove( element, "axis: default" ); + draggableTestHelpers.shouldMove( element, "axis: default" ); // Only horizontal element.draggable( "option", "axis", "x" ); - TestHelpers.draggable.testDrag( element, element, 50, 50, 50, 0, "axis: x as option" ); + draggableTestHelpers.testDrag( element, element, 50, 50, 50, 0, "axis: x as option" ); // Vertical only element.draggable( "option", "axis", "y" ); - TestHelpers.draggable.testDrag( element, element, 50, 50, 0, 50, "axis: y as option" ); + draggableTestHelpers.testDrag( element, element, 50, 50, 0, 50, "axis: y as option" ); }); @@ -161,12 +165,12 @@ test( "{ cancel: 'input,textarea,button,select,option' }, default", function() { $( "
" ).appendTo( "#qunit-fixture" ); var element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" }); - TestHelpers.draggable.shouldMove( element, "cancel: default, element dragged" ); + draggableTestHelpers.shouldMove( element, "cancel: default, element dragged" ); element.draggable( "destroy" ); element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" }); - TestHelpers.draggable.shouldNotDrag( element, "cancel: default, input dragged", "#draggable-option-cancel-default input" ); + draggableTestHelpers.shouldNotDrag( element, "cancel: default, input dragged", "#draggable-option-cancel-default input" ); element.draggable( "destroy" ); }); @@ -174,12 +178,12 @@ test( "{ cancel: 'span' }", function() { expect( 4 ); var element = $( "#draggable2" ).draggable(); - TestHelpers.draggable.shouldMove( element, "cancel: default, span dragged", "#draggable2 span" ); + draggableTestHelpers.shouldMove( element, "cancel: default, span dragged", "#draggable2 span" ); element.draggable( "destroy" ); element = $( "#draggable2" ).draggable({ cancel: "span" }); - TestHelpers.draggable.shouldNotDrag( element, "cancel: span, span dragged", "#draggable2 span" ); + draggableTestHelpers.shouldNotDrag( element, "cancel: span, span dragged", "#draggable2 span" ); }); test( "{ cancel: ? }, unexpected", function() { @@ -197,7 +201,7 @@ test( "{ cancel: ? }, unexpected", function() { $.each( unexpected, function( key, val ) { element = $( "#draggable2" ).draggable({ cancel: val }); - TestHelpers.draggable.shouldMove( element, "cancel: " + key ); + draggableTestHelpers.shouldMove( element, "cancel: " + key ); element.draggable( "destroy" ); }); }); @@ -215,15 +219,15 @@ test( "{ cancel: Selectors }, matching parent selector", function() { $( "#wrapping a" ).append( element ); - TestHelpers.draggable.shouldMove( element, "drag span child", "#draggable2 span" ); - TestHelpers.draggable.shouldNotDrag( $( "#draggable2 span a" ), "drag span a" ); - TestHelpers.draggable.shouldNotDrag( $( "#wrapping a" ), "drag wrapping a" ); + draggableTestHelpers.shouldMove( element, "drag span child", "#draggable2 span" ); + draggableTestHelpers.shouldNotDrag( $( "#draggable2 span a" ), "drag span a" ); + draggableTestHelpers.shouldNotDrag( $( "#wrapping a" ), "drag wrapping a" ); $( "#draggable2" ).draggable( "option", "cancel", "span > a" ); $( "#draggable2" ).find( "a" ).append( "" ); - TestHelpers.draggable.shouldMove( element, "drag span child", $( "#draggable2 span a" ).last() ); - TestHelpers.draggable.shouldNotDrag( $( "#draggable2 span a" ).first(), "drag span a first child" ); + draggableTestHelpers.shouldMove( element, "drag span child", $( "#draggable2 span a" ).last() ); + draggableTestHelpers.shouldNotDrag( $( "#draggable2 span a" ).first(), "drag span a first child" ); }); */ @@ -235,13 +239,13 @@ test( "cancelement, default, switching after initialization", function() { var input = $( "#draggable-option-cancel-default input" ), element = $( "#draggable-option-cancel-default" ).draggable(); - TestHelpers.draggable.shouldNotDrag( element, "cancel: default, input dragged", input ); + draggableTestHelpers.shouldNotDrag( element, "cancel: default, input dragged", input ); element.draggable( "option", "cancel", "textarea" ); - TestHelpers.draggable.shouldMove( element, "cancel: textarea, input dragged", input ); + draggableTestHelpers.shouldMove( element, "cancel: textarea, input dragged", input ); element.draggable( "option", "cancel", "input" ); - TestHelpers.draggable.shouldNotDrag( element, "cancel: input, input dragged", input ); + draggableTestHelpers.shouldNotDrag( element, "cancel: input, input dragged", input ); }); test( "connectToSortable, dragging out of a sortable", function() { @@ -436,8 +440,8 @@ test( "{ containment: Element }", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ), - top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" ) + left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), + top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) }; element.simulate( "drag", { @@ -456,8 +460,8 @@ test( "{ containment: Selector }", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ), - top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" ) + left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), + top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) }; element.simulate( "drag", { @@ -476,7 +480,7 @@ test( "{ containment: [x1, y1, x2, y2] }", function() { element.draggable( "option", "containment", [ eo.left, eo.top, eo.left + element.width() + 5, eo.top + element.height() + 5 ] ); - TestHelpers.draggable.testDrag( element, element, -100, -100, 0, 0, "containment: [x1, y1, x2, y2]" ); + draggableTestHelpers.testDrag( element, element, -100, -100, 0, 0, "containment: [x1, y1, x2, y2]" ); }); test( "{ containment: 'parent' }, relative", function() { @@ -487,8 +491,8 @@ test( "{ containment: 'parent' }, relative", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ), - top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" ) + left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), + top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) }; element.simulate( "drag", { @@ -507,8 +511,8 @@ test( "{ containment: 'parent' }, absolute", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + TestHelpers.draggable.border( p, "left" ) + TestHelpers.draggable.margin( element, "left" ), - top: po.top + TestHelpers.draggable.border( p, "top" ) + TestHelpers.draggable.margin( element, "top" ) + left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), + top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) }; element.simulate( "drag", { @@ -531,8 +535,8 @@ test( "containment, account for border", function( assert ) { }), parentBottom = parent.offset().top + parent.outerHeight(), parentRight = parent.offset().left + parent.outerWidth(), - parentBorderBottom = TestHelpers.draggable.border( parent, "bottom" ), - parentBorderRight = TestHelpers.draggable.border( parent, "right" ); + parentBorderBottom = draggableTestHelpers.border( parent, "bottom" ), + parentBorderRight = draggableTestHelpers.border( parent, "right" ); el.css({ height: "5px", @@ -587,16 +591,16 @@ test( "containment, default, switching after initialization", function() { po = element.parent().offset(), containment = [ po.left - 100, po.top - 100, po.left + 500, po.top + 500 ]; - TestHelpers.draggable.testDrag( element, element, -100, -100, -100, -100, "containment: default" ); + draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: default" ); element.draggable( "option", "containment", "parent" ).css({ top: 0, left: 0 }); - TestHelpers.draggable.testDrag( element, element, -100, -100, 0, 0, "containment: parent as option" ); + draggableTestHelpers.testDrag( element, element, -100, -100, 0, 0, "containment: parent as option" ); element.draggable( "option", "containment", containment ).css({ top: 0, left: 0 }); - TestHelpers.draggable.testDrag( element, element, -100, -100, -100, -100, "containment: array as option" ); + draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: array as option" ); element.draggable( "option", "containment", false ); - TestHelpers.draggable.testDrag( element, element, -100, -100, -100, -100, "containment: false as option" ); + draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: false as option" ); }); test( "{ cursor: 'auto' }, default", function() { @@ -674,7 +678,7 @@ test( "#6889: Cursor doesn't revert to pre-dragging state after revert action wh }), expected = getCursor(); - if ( TestHelpers.draggable.unreliableContains ) { + if ( draggableTestHelpers.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -690,17 +694,17 @@ test( "cursor, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable(); - TestHelpers.draggable.trackMouseCss( element ); + draggableTestHelpers.trackMouseCss( element ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "auto" ); element.draggable( "option", "cursor", "move" ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "move" ); element.draggable( "option", "cursor", "ns-resize" ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "ns-resize" ); }); @@ -727,11 +731,11 @@ test( "cursorAt", function() { equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" ); equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" ); } else if ( testData.cursorAt.right ) { - equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" ); - equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" ); + equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); + equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); } else { - equal( event.clientX - ui.offset.left, testData.x + TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" ); - equal( event.clientY - ui.offset.top, testData.y + TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" ); + equal( event.clientX - ui.offset.left, testData.x + draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); + equal( event.clientY - ui.offset.top, testData.y + draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); } } }); @@ -769,11 +773,11 @@ test( "cursorAt, switching after initialization", function() { equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" ); equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" ); } else if ( testData.cursorAt.right ) { - equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" ); - equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" ); + equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); + equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); } else { - equal( event.clientX - ui.offset.left, testData.x + TestHelpers.draggable.unreliableOffset, testName + " " + position + " left" ); - equal( event.clientY - ui.offset.top, testData.y + TestHelpers.draggable.unreliableOffset, testName + " " + position + " top" ); + equal( event.clientX - ui.offset.left, testData.x + draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); + equal( event.clientY - ui.offset.top, testData.y + draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); } } }); @@ -795,29 +799,29 @@ test( "disabled", function() { var element = $( "#draggable1" ).draggable(); - TestHelpers.draggable.shouldMove( element, "disabled: default" ); + draggableTestHelpers.shouldMove( element, "disabled: default" ); element.draggable( "option", "disabled", true ); - TestHelpers.draggable.shouldNotDrag( element, "option: disabled true" ); + draggableTestHelpers.shouldNotDrag( element, "option: disabled true" ); element.draggable( "option", "disabled", false ); - TestHelpers.draggable.shouldMove( element, "option: disabled false" ); + draggableTestHelpers.shouldMove( element, "option: disabled false" ); }); test( "{ grid: [50, 50] }, relative", function() { expect( 4 ); var element = $( "#draggable1" ).draggable({ grid: [ 50, 50 ] }); - TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] relative" ); - TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] relative" ); + draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] relative" ); + draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] relative" ); }); test( "{ grid: [50, 50] }, absolute", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ grid: [ 50, 50 ] }); - TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] absolute" ); - TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] absolute" ); + draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] absolute" ); + draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] absolute" ); }); test( "grid, switching after initialization", function() { @@ -826,13 +830,13 @@ test( "grid, switching after initialization", function() { var element = $( "#draggable1" ).draggable(); // Forward - TestHelpers.draggable.testDrag( element, element, 24, 24, 24, 24, "grid: default" ); - TestHelpers.draggable.testDrag( element, element, 0, 0, 0, 0, "grid: default" ); + draggableTestHelpers.testDrag( element, element, 24, 24, 24, 24, "grid: default" ); + draggableTestHelpers.testDrag( element, element, 0, 0, 0, 0, "grid: default" ); element.draggable( "option", "grid", [ 50, 50 ] ); - TestHelpers.draggable.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] as option" ); - TestHelpers.draggable.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] as option" ); + draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] as option" ); + draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] as option" ); }); test( "{ handle: 'span' }", function() { @@ -840,9 +844,9 @@ test( "{ handle: 'span' }", function() { var element = $( "#draggable2" ).draggable({ handle: "span" }); - TestHelpers.draggable.shouldMove( element, "handle: span", "#draggable2 span"); - TestHelpers.draggable.shouldMove( element, "handle: span child", "#draggable2 span em" ); - TestHelpers.draggable.shouldNotDrag( element, "handle: span element" ); + draggableTestHelpers.shouldMove( element, "handle: span", "#draggable2 span"); + draggableTestHelpers.shouldMove( element, "handle: span child", "#draggable2 span em" ); + draggableTestHelpers.shouldNotDrag( element, "handle: span element" ); }); test( "handle, default, switching after initialization", function() { @@ -850,31 +854,31 @@ test( "handle, default, switching after initialization", function() { var element = $( "#draggable2" ).draggable(); - TestHelpers.draggable.shouldMove( element, "handle: default, element dragged" ); - TestHelpers.draggable.shouldMove( element, "handle: default, span dragged", "#draggable2 span" ); + draggableTestHelpers.shouldMove( element, "handle: default, element dragged" ); + draggableTestHelpers.shouldMove( element, "handle: default, span dragged", "#draggable2 span" ); // Switch element.draggable( "option", "handle", "span" ); - TestHelpers.draggable.shouldNotDrag( element, "handle: span as option, element dragged" ); - TestHelpers.draggable.shouldMove( element, "handle: span as option, span dragged", "#draggable2 span" ); + draggableTestHelpers.shouldNotDrag( element, "handle: span as option, element dragged" ); + draggableTestHelpers.shouldMove( element, "handle: span as option, span dragged", "#draggable2 span" ); // And back element.draggable( "option", "handle", false ); - TestHelpers.draggable.shouldMove( element, "handle: false as option, element dragged" ); - TestHelpers.draggable.shouldMove( element, "handle: false as option, span dragged", "#draggable2 span" ); + draggableTestHelpers.shouldMove( element, "handle: false as option, element dragged" ); + draggableTestHelpers.shouldMove( element, "handle: false as option, span dragged", "#draggable2 span" ); }); test( "helper, default, switching after initialization", function() { expect( 6 ); var element = $( "#draggable1" ).draggable(); - TestHelpers.draggable.shouldMove( element, "helper: default" ); + draggableTestHelpers.shouldMove( element, "helper: default" ); element.draggable( "option", "helper", "clone" ); - TestHelpers.draggable.shouldMove( element, "helper: clone" ); + draggableTestHelpers.shouldMove( element, "helper: clone" ); element.draggable( "option", "helper", "original" ); - TestHelpers.draggable.shouldMove( element, "helper: original" ); + draggableTestHelpers.shouldMove( element, "helper: original" ); }); // http://bugs.jqueryui.com/ticket/9446 @@ -888,7 +892,7 @@ test( "helper, function returning original element", function() { } }); - TestHelpers.draggable.testDragHelperOffset( element, 100, 100, 100, 100, "original element is draggable" ); + draggableTestHelpers.testDragHelperOffset( element, 100, 100, 100, 100, "original element is draggable" ); element.simulate( "drag", { dx: 100, @@ -907,25 +911,25 @@ function testHelperPosition( scrollPositions, position, helper, scrollElements, }); if ( scrollElements.length === 1 && scrollElements[ 0 ] === "#scrollParent" ) { - TestHelpers.draggable.setScrollable( "#main", false ); - TestHelpers.draggable.setScrollable( "#scrollParent", true ); + draggableTestHelpers.setScrollable( "#main", false ); + draggableTestHelpers.setScrollable( "#scrollParent", true ); } for ( j = 0; j < scrollPositions.length; j++ ) { for ( i = 0; i < scrollElements.length; i++ ) { - TestHelpers.draggable.setScroll( scrollElements[ i ] ); + draggableTestHelpers.setScroll( scrollElements[ i ] ); } - TestHelpers.draggable.testScroll( element, scrollPositions[ j ] ); + draggableTestHelpers.testScroll( element, scrollPositions[ j ] ); for ( i = 0; i < scrollElements.length; i++ ) { - TestHelpers.draggable.restoreScroll( scrollElements[ i ] ); + draggableTestHelpers.restoreScroll( scrollElements[ i ] ); } } if ( scrollElements.length === 1 && scrollElements[ 1 ] === "#scrollParent" ) { - TestHelpers.draggable.setScrollable( "#main", true ); - TestHelpers.draggable.setScrollable( "#scrollParent", false ); + draggableTestHelpers.setScrollable( "#main", true ); + draggableTestHelpers.setScrollable( "#scrollParent", false ); } }); } @@ -983,15 +987,15 @@ test( "opacity, default, switching after initialization", function() { } }); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( opacity, 1 ); element.draggable( "option", "opacity", 0.5 ); - TestHelpers.draggable.move( element, 2, 1 ); + draggableTestHelpers.move( element, 2, 1 ); equal( opacity, 0.5 ); element.draggable( "option", "opacity", false ); - TestHelpers.draggable.move( element, 3, 1 ); + draggableTestHelpers.move( element, 3, 1 ); equal( opacity, 1 ); }); @@ -1002,13 +1006,13 @@ asyncTest( "revert and revertDuration", function() { revert: true, revertDuration: 0 }); - TestHelpers.draggable.shouldMovePositionButNotOffset( element, "revert: true, revertDuration: 0 should revert immediately" ); + draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: true, revertDuration: 0 should revert immediately" ); $( "#draggable2" ).draggable( "option", "revert", "invalid" ); - TestHelpers.draggable.shouldMovePositionButNotOffset( element, "revert: invalid, revertDuration: 0 should revert immediately" ); + draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: invalid, revertDuration: 0 should revert immediately" ); $( "#draggable2" ).draggable( "option", "revert", false ); - TestHelpers.draggable.shouldMove( element, "revert: false should allow movement" ); + draggableTestHelpers.shouldMove( element, "revert: false should allow movement" ); $( "#draggable2" ).draggable( "option", { revert: true, @@ -1019,7 +1023,7 @@ asyncTest( "revert and revertDuration", function() { }); // animation are async, so test for it asynchronously - TestHelpers.draggable.move( element, 50, 50 ); + draggableTestHelpers.move( element, 50, 50 ); setTimeout( function() { ok( $( "#draggable2" ).is( ":animated" ), "revert: true with revertDuration should animate" ); }); @@ -1035,7 +1039,7 @@ test( "revert: valid", function() { $( "#droppable" ).droppable(); - TestHelpers.draggable.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable" ); + draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable" ); }); test( "scope", function() { @@ -1049,17 +1053,17 @@ test( "scope", function() { $( "#droppable" ).droppable({ scope: "tasks" }); - TestHelpers.draggable.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable in scope" ); + draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable in scope" ); $( "#droppable" ).droppable( "destroy" ).droppable({ scope: "nottasks" }); - TestHelpers.draggable.shouldMove( element, "revert: valid reverts when dropped on a droppable out of scope" ); + draggableTestHelpers.shouldMove( element, "revert: valid reverts when dropped on a droppable out of scope" ); }); test( "scroll, scrollSensitivity, and scrollSpeed", function() { expect( 2 ); - TestHelpers.draggable.setScrollable( "#main", false ); + draggableTestHelpers.setScrollable( "#main", false ); var currentScrollTop, viewportHeight = $( window ).height(), @@ -1101,7 +1105,7 @@ test( "scroll, scrollSensitivity, and scrollSpeed", function() { moves: 1 }); - TestHelpers.draggable.restoreScroll( document ); + draggableTestHelpers.restoreScroll( document ); }); test( "scroll ignores containers that are overflow: hidden", function() { @@ -1140,7 +1144,7 @@ test( "scroll ignores containers that are overflow: hidden", function() { test( "#6817: auto scroll goes double distance when dragging", function( assert ) { expect( 2 ); - TestHelpers.draggable.restoreScroll( document ); + draggableTestHelpers.restoreScroll( document ); var offsetBefore, distance = 10, @@ -1171,7 +1175,7 @@ test( "#6817: auto scroll goes double distance when dragging", function( assert moves: 1 }); - TestHelpers.draggable.restoreScroll( document ); + draggableTestHelpers.restoreScroll( document ); }); test( "snap, snapMode, and snapTolerance", function( assert ) { @@ -1333,7 +1337,7 @@ test( "#8459: element can snap to an element that was removed during drag", func }); // Support: Opera 12.10, Safari 5.1, jQuery <1.8 - if ( TestHelpers.draggable.unreliableContains ) { + if ( draggableTestHelpers.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -1390,10 +1394,10 @@ test( "stack", function() { stack: "#draggable1, #draggable2" }); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( element.css( "zIndex" ), "2", "stack increments zIndex correctly" ); - TestHelpers.draggable.move( element2, 1, 1 ); + draggableTestHelpers.move( element2, 1, 1 ); equal( element2.css( "zIndex" ), "3", "stack increments zIndex correctly" ); }); @@ -1431,15 +1435,15 @@ test( "zIndex, default, switching after initialization", function() { element.css( "z-index", 1 ); - TestHelpers.draggable.move( element, 1, 1 ); + draggableTestHelpers.move( element, 1, 1 ); equal( zindex, 1 ); element.draggable( "option", "zIndex", 5 ); - TestHelpers.draggable.move( element, 2, 1 ); + draggableTestHelpers.move( element, 2, 1 ); equal( zindex, 5 ); element.draggable( "option", "zIndex", false ); - TestHelpers.draggable.move( element, 3, 1 ); + draggableTestHelpers.move( element, 3, 1 ); equal( zindex, 1 ); }); @@ -1486,4 +1490,4 @@ test( "iframeFix", function() { }); }); -})( jQuery ); +} ); diff --git a/tests/unit/draggable/draggable_test_helpers.js b/tests/unit/draggable/draggable_test_helpers.js index 1b004e7cfab..dcf2d62974d 100644 --- a/tests/unit/draggable/draggable_test_helpers.js +++ b/tests/unit/draggable/draggable_test_helpers.js @@ -1,4 +1,7 @@ -TestHelpers.draggable = { +define( function() { + +var draggableTestHelpers = { + // TODO: remove the unreliable offset hacks unreliableOffset: $.ui.ie && ( !document.documentMode || document.documentMode < 8 ) ? 2 : 0, // Support: Opera 12.10, Safari 5.1, jQuery <1.8 @@ -35,8 +38,8 @@ TestHelpers.draggable = { }); }, testDrag: function( el, handle, dx, dy, expectedDX, expectedDY, msg ) { - TestHelpers.draggable.testDragPosition( el, dx, dy, expectedDX, expectedDY, msg ); - TestHelpers.draggable.testDragOffset( el, dx, dy, expectedDX, expectedDY, msg ); + draggableTestHelpers.testDragPosition( el, dx, dy, expectedDX, expectedDY, msg ); + draggableTestHelpers.testDragOffset( el, dx, dy, expectedDX, expectedDY, msg ); $( handle ).simulate( "drag", { dx: dx, @@ -45,8 +48,8 @@ TestHelpers.draggable = { }, shouldMovePositionButNotOffset: function( el, msg, handle ) { handle = handle || el; - TestHelpers.draggable.testDragPosition( el, 100, 100, 100, 100, msg ); - TestHelpers.draggable.testDragHelperOffset( el, 100, 100, 0, 0, msg ); + draggableTestHelpers.testDragPosition( el, 100, 100, 100, 100, msg ); + draggableTestHelpers.testDragHelperOffset( el, 100, 100, 0, 0, msg ); $( handle ).simulate( "drag", { dx: 100, @@ -55,11 +58,11 @@ TestHelpers.draggable = { }, shouldMove: function( el, msg, handle ) { handle = handle || el; - TestHelpers.draggable.testDrag( el, handle, 100, 100, 100, 100, msg ); + draggableTestHelpers.testDrag( el, handle, 100, 100, 100, 100, msg ); }, shouldNotMove: function( el, msg, handle ) { handle = handle || el; - TestHelpers.draggable.testDrag( el, handle, 100, 100, 0, 0, msg ); + draggableTestHelpers.testDrag( el, handle, 100, 100, 0, 0, msg ); }, shouldNotDrag: function( el, msg, handle ) { handle = handle || el; @@ -93,7 +96,7 @@ TestHelpers.draggable = { testScroll: function( el, position ) { var oldPosition = $( "#main" ).css( "position" ); $( "#main" ).css({ position: position, top: "0px", left: "0px" }); - TestHelpers.draggable.shouldMove( el, position + " parent" ); + draggableTestHelpers.shouldMove( el, position + " parent" ); $( "#main" ).css( "position", oldPosition ); }, restoreScroll: function( what ) { @@ -129,3 +132,7 @@ TestHelpers.draggable = { }); } }; + +return draggableTestHelpers; + +} ); From f5eae5bac5e65991fdf2bf1d7a993e48cc3cf9ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 12:56:07 -0400 Subject: [PATCH 08/29] Effects: Convert tests to new infrastructure --- tests/unit/effects/effects.html | 34 ++--------------------------- tests/unit/effects/effects_core.js | 25 ++++++++++++++++++--- tests/unit/effects/effects_scale.js | 8 +++++-- 3 files changed, 30 insertions(+), 37 deletions(-) diff --git a/tests/unit/effects/effects.html b/tests/unit/effects/effects.html index 352224a7b99..d444d3853a6 100644 --- a/tests/unit/effects/effects.html +++ b/tests/unit/effects/effects.html @@ -4,39 +4,9 @@ jQuery UI Effects Test Suite - - - - - - - + - - - - - #qunit-fixture { width: 1000px; diff --git a/tests/unit/effects/effects_core.js b/tests/unit/effects/effects_core.js index 346e404c25c..76fcaa06221 100644 --- a/tests/unit/effects/effects_core.js +++ b/tests/unit/effects/effects_core.js @@ -1,4 +1,23 @@ -(function($) { +define( [ + "jquery", + "lib/common", + "ui/effect", + "ui/effect-blind", + "ui/effect-bounce", + "ui/effect-clip", + "ui/effect-drop", + "ui/effect-explode", + "ui/effect-fade", + "ui/effect-fold", + "ui/effect-highlight", + "ui/effect-puff", + "ui/effect-pulsate", + "ui/effect-scale", + "ui/effect-shake", + "ui/effect-size", + "ui/effect-slide", + "ui/effect-transfer" +], function( $, common ) { function present( value, array, message ) { QUnit.push( jQuery.inArray( value, array ) !== -1, value, array, message ); @@ -242,7 +261,7 @@ test( "createPlaceholder: preserves layout affecting properties", function() { $.each( $.effects.effect, function( effect ) { module( "effects." + effect ); - TestHelpers.testJshint( "effect-" + effect ); + common.testJshint( "effect-" + effect ); if ( effect === "transfer" ) { return; @@ -319,4 +338,4 @@ $.each( $.effects.effect, function( effect ) { }); }); -})(jQuery); +} ); diff --git a/tests/unit/effects/effects_scale.js b/tests/unit/effects/effects_scale.js index 03446367dc3..186daf09fea 100644 --- a/tests/unit/effects/effects_scale.js +++ b/tests/unit/effects/effects_scale.js @@ -1,4 +1,8 @@ -(function( $ ) { +define( [ + "jquery", + "ui/effect-scale" +], function( $ ) { + module( "effect.scale: Scale" ); function run( position, v, h, vo, ho ) { @@ -65,4 +69,4 @@ $(function() { } }); -})( jQuery ); +} ); From 797118d32a14663af8016120978fd3ee43ac31b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 13:04:04 -0400 Subject: [PATCH 09/29] Menu: Convert tests to new infrastructure --- tests/unit/menu/menu.html | 27 ++------------------------- tests/unit/menu/menu_common.js | 9 ++++++++- tests/unit/menu/menu_core.js | 10 +++++++--- tests/unit/menu/menu_events.js | 16 ++++++++++------ tests/unit/menu/menu_methods.js | 22 +++++++++++++--------- tests/unit/menu/menu_options.js | 16 ++++++++++------ tests/unit/menu/menu_test_helpers.js | 6 +++--- 7 files changed, 53 insertions(+), 53 deletions(-) diff --git a/tests/unit/menu/menu.html b/tests/unit/menu/menu.html index 114382587c5..5f11f441414 100644 --- a/tests/unit/menu/menu.html +++ b/tests/unit/menu/menu.html @@ -4,31 +4,8 @@ jQuery UI Menu Test Suite - - - - - - - - - - - - - - - - + + .ui-menu { font-size: 15px; diff --git a/tests/unit/menu/menu_common.js b/tests/unit/menu/menu_common.js index 942e9e9f954..0f0a04de880 100644 --- a/tests/unit/menu/menu_common.js +++ b/tests/unit/menu/menu_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "menu", { +define( [ + "lib/common", + "ui/menu" +], function( common ) { + +common.testWidget( "menu", { defaults: { classes: {}, disabled: false, @@ -20,3 +25,5 @@ TestHelpers.commonWidgetTests( "menu", { select: null } }); + +} ); diff --git a/tests/unit/menu/menu_core.js b/tests/unit/menu/menu_core.js index 9c3ba873a66..3dd2c78e13f 100644 --- a/tests/unit/menu/menu_core.js +++ b/tests/unit/menu/menu_core.js @@ -1,4 +1,8 @@ -(function( $ ) { +define( [ + "jquery", + "./menu_test_helpers", + "ui/menu" +], function( $, menuTestHelpers ) { module( "menu: core" ); @@ -47,7 +51,7 @@ asyncTest( "#9044: Autofocus issue with dialog opened from menu widget", functio $( "#test9044" ).focus(); }); - TestHelpers.menu.click( element, "3" ); + menuTestHelpers.click( element, "3" ); setTimeout( function() { equal( document.activeElement.id, "test9044", "Focus was swallowed by menu" ); $( "#test9044" ).remove(); @@ -69,4 +73,4 @@ asyncTest( "#9532: Need a way in Menu to keep ui-state-active class on selected }); }); -})( jQuery ); +} ); diff --git a/tests/unit/menu/menu_events.js b/tests/unit/menu/menu_events.js index 4985e067762..3e2aa61bf43 100644 --- a/tests/unit/menu/menu_events.js +++ b/tests/unit/menu/menu_events.js @@ -1,12 +1,16 @@ -(function( $ ) { +define( [ + "jquery", + "./menu_test_helpers", + "ui/menu" +], function( $, menuTestHelpers ) { -var log = TestHelpers.menu.log, - logOutput = TestHelpers.menu.logOutput, - click = TestHelpers.menu.click; +var log = menuTestHelpers.log, + logOutput = menuTestHelpers.logOutput, + click = menuTestHelpers.click; module( "menu: events", { setup: function() { - TestHelpers.menu.clearLog(); + menuTestHelpers.clearLog(); } }); @@ -688,4 +692,4 @@ asyncTest( "#10571: When typing in a menu, only menu-items should be focused", f }); }); -})( jQuery ); +} ); diff --git a/tests/unit/menu/menu_methods.js b/tests/unit/menu/menu_methods.js index 840ccbd1737..ad30e5f138c 100644 --- a/tests/unit/menu/menu_methods.js +++ b/tests/unit/menu/menu_methods.js @@ -1,21 +1,25 @@ -(function( $ ) { +define( [ + "jquery", + "./menu_test_helpers", + "ui/menu" +], function( $, menuTestHelpers ) { -var log = TestHelpers.menu.log, - logOutput = TestHelpers.menu.logOutput, - click = TestHelpers.menu.click; +var log = menuTestHelpers.log, + logOutput = menuTestHelpers.logOutput, + click = menuTestHelpers.click; module( "menu: methods", { setup: function() { - TestHelpers.menu.clearLog(); + menuTestHelpers.clearLog(); } }); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 2 ); - domEqual( "#menu2", function() { + assert.domEqual( "#menu2", function() { $( "#menu2" ).menu().menu( "destroy" ); }); - domEqual( "#menu5", function() { + assert.domEqual( "#menu5", function() { $( "#menu5").menu().menu( "destroy" ); }); }); @@ -109,4 +113,4 @@ test( "widget", function() { // TODO: test select method -})( jQuery ); +} ); diff --git a/tests/unit/menu/menu_options.js b/tests/unit/menu/menu_options.js index 3df5473348d..91630e14b20 100644 --- a/tests/unit/menu/menu_options.js +++ b/tests/unit/menu/menu_options.js @@ -1,12 +1,16 @@ -(function( $ ) { +define( [ + "jquery", + "./menu_test_helpers", + "ui/menu" +], function( $, menuTestHelpers ) { -var log = TestHelpers.menu.log, - logOutput = TestHelpers.menu.logOutput, - click = TestHelpers.menu.click; +var log = menuTestHelpers.log, + logOutput = menuTestHelpers.logOutput, + click = menuTestHelpers.click; module( "menu: options", { setup: function() { - TestHelpers.menu.clearLog(); + menuTestHelpers.clearLog(); } }); @@ -118,4 +122,4 @@ test( "{ role: null }", function( assert ) { }); }); -})( jQuery ); +} ); diff --git a/tests/unit/menu/menu_test_helpers.js b/tests/unit/menu/menu_test_helpers.js index ea273c765bf..bfed14d7403 100644 --- a/tests/unit/menu/menu_test_helpers.js +++ b/tests/unit/menu/menu_test_helpers.js @@ -1,9 +1,9 @@ -(function() { +define( function() { var lastItem, log = []; -TestHelpers.menu = { +return { log: function( message, clear ) { if ( clear ) { log.length = 0; @@ -30,4 +30,4 @@ TestHelpers.menu = { } }; -})(); +} ); From f429be041fe39efbaf373cd10789312549149bd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 13:08:27 -0400 Subject: [PATCH 10/29] Position: Convert tests to new infrastructure --- tests/unit/position/position.html | 16 ++-------------- tests/unit/position/position_core.js | 10 +++++++--- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/tests/unit/position/position.html b/tests/unit/position/position.html index 334fbbb7826..1d408728117 100644 --- a/tests/unit/position/position.html +++ b/tests/unit/position/position.html @@ -4,20 +4,8 @@ jQuery UI Position Test Suite - - - - - - - - - - + +
diff --git a/tests/unit/position/position_core.js b/tests/unit/position/position_core.js index 7176e37e147..c480e21789b 100644 --- a/tests/unit/position/position_core.js +++ b/tests/unit/position/position_core.js @@ -1,4 +1,8 @@ -(function( $ ) { +define( [ + "jquery", + "lib/common", + "ui/position" +], function( $, common ) { var win = $( window ), scrollTopSupport = function() { @@ -16,7 +20,7 @@ module( "position", { } }); -TestHelpers.testJshint( "position" ); +common.testJshint( "position" ); test( "my, at, of", function() { expect( 4 ); @@ -763,4 +767,4 @@ test( "bug #8710: flip if flipped position fits more", function() { }, "no flip - top fits less" ); }); -}( jQuery ) ); +} ); From 0df224fcb4250b891ffc0ea7a4e165d01b5f97d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:27:05 -0400 Subject: [PATCH 11/29] Progressbar: Convert tests to new infrastructure --- tests/unit/progressbar/progressbar.html | 26 ++----------------- tests/unit/progressbar/progressbar_common.js | 9 ++++++- tests/unit/progressbar/progressbar_core.js | 7 +++-- tests/unit/progressbar/progressbar_events.js | 7 +++-- tests/unit/progressbar/progressbar_methods.js | 11 +++++--- tests/unit/progressbar/progressbar_options.js | 7 +++-- 6 files changed, 32 insertions(+), 35 deletions(-) diff --git a/tests/unit/progressbar/progressbar.html b/tests/unit/progressbar/progressbar.html index 1dae6b666ae..351ed4e2180 100644 --- a/tests/unit/progressbar/progressbar.html +++ b/tests/unit/progressbar/progressbar.html @@ -4,30 +4,8 @@ jQuery UI Progressbar Test Suite - - - - - - - - - - - - - - - + + diff --git a/tests/unit/progressbar/progressbar_common.js b/tests/unit/progressbar/progressbar_common.js index 0608f09f792..c949f136f9c 100644 --- a/tests/unit/progressbar/progressbar_common.js +++ b/tests/unit/progressbar/progressbar_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "progressbar", { +define( [ + "lib/common", + "ui/progressbar" +], function( common ) { + +common.testWidget( "progressbar", { defaults: { classes: { "ui-progressbar": "ui-corner-all", @@ -15,3 +20,5 @@ TestHelpers.commonWidgetTests( "progressbar", { create: null } }); + +} ); diff --git a/tests/unit/progressbar/progressbar_core.js b/tests/unit/progressbar/progressbar_core.js index 60ff3141128..05eea9ef7b1 100644 --- a/tests/unit/progressbar/progressbar_core.js +++ b/tests/unit/progressbar/progressbar_core.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/progressbar" +], function( $ ) { module( "progressbar: core" ); @@ -58,4 +61,4 @@ test( "accessibility", function() { equal( element.attr( "aria-valuenow" ), null, "aria-valuenow" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/progressbar/progressbar_events.js b/tests/unit/progressbar/progressbar_events.js index ed3da169aaf..a40b2c43218 100644 --- a/tests/unit/progressbar/progressbar_events.js +++ b/tests/unit/progressbar/progressbar_events.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/progressbar" +], function( $ ) { module( "progressbar: events" ); @@ -52,4 +55,4 @@ test( "complete", function() { element.progressbar( "value", value ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/progressbar/progressbar_methods.js b/tests/unit/progressbar/progressbar_methods.js index c665566b53b..eaf0a5c7665 100644 --- a/tests/unit/progressbar/progressbar_methods.js +++ b/tests/unit/progressbar/progressbar_methods.js @@ -1,10 +1,13 @@ -(function( $ ) { +define( [ + "jquery", + "ui/progressbar" +], function( $ ) { module( "progressbar: methods" ); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 1 ); - domEqual( "#progressbar", function() { + assert.domEqual( "#progressbar", function() { $( "#progressbar" ).progressbar().progressbar( "destroy" ); }); }); @@ -36,4 +39,4 @@ test( "widget", function() { strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/progressbar/progressbar_options.js b/tests/unit/progressbar/progressbar_options.js index 739c97bd9a1..7b6ac9db260 100644 --- a/tests/unit/progressbar/progressbar_options.js +++ b/tests/unit/progressbar/progressbar_options.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/progressbar" +], function( $ ) { module( "progressbar: options" ); @@ -73,4 +76,4 @@ test( "change max below value", function() { "value constrained at max" ); }); -}( jQuery ) ); +} ); From e0399fb3129240940e666dd1658be3b00743601d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:33:25 -0400 Subject: [PATCH 12/29] Resizable: Convert tests to new infrastructure --- tests/unit/resizable/resizable.html | 29 +---- tests/unit/resizable/resizable_common.js | 9 +- tests/unit/resizable/resizable_core.js | 60 +++++----- tests/unit/resizable/resizable_events.js | 29 ++--- tests/unit/resizable/resizable_methods.js | 10 +- tests/unit/resizable/resizable_options.js | 111 +++++++++--------- .../unit/resizable/resizable_test_helpers.js | 6 +- 7 files changed, 121 insertions(+), 133 deletions(-) diff --git a/tests/unit/resizable/resizable.html b/tests/unit/resizable/resizable.html index 3713252b308..5190e5f5c3e 100644 --- a/tests/unit/resizable/resizable.html +++ b/tests/unit/resizable/resizable.html @@ -4,33 +4,8 @@ jQuery UI Resizable Test Suite - - - - - - - - - - - - - - - - - + + #container { width: 300px; diff --git a/tests/unit/resizable/resizable_common.js b/tests/unit/resizable/resizable_common.js index c3255ff9176..822a4db87e9 100644 --- a/tests/unit/resizable/resizable_common.js +++ b/tests/unit/resizable/resizable_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "resizable", { +define( [ + "lib/common", + "ui/resizable" +], function( common ) { + +common.testWidget( "resizable", { defaults: { alsoResize: false, animate: false, @@ -31,3 +36,5 @@ TestHelpers.commonWidgetTests( "resizable", { stop: null } }); + +} ); diff --git a/tests/unit/resizable/resizable_core.js b/tests/unit/resizable/resizable_core.js index f43cde6237c..2e643c96768 100644 --- a/tests/unit/resizable/resizable_core.js +++ b/tests/unit/resizable/resizable_core.js @@ -1,8 +1,8 @@ -/* - * resizable_core.js - */ - -(function($) { +define( [ + "jquery", + "./resizable_test_helpers", + "ui/resizable" +], function( $, resizableTestHelpers ) { module("resizable: core"); @@ -30,10 +30,10 @@ test("n", function() { var handle = ".ui-resizable-n", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, 0, -50); + resizableTestHelpers.drag(handle, 0, -50); equal( target.height(), 150, "compare height" ); - TestHelpers.resizable.drag(handle, 0, 50); + resizableTestHelpers.drag(handle, 0, 50); equal( target.height(), 100, "compare height" ); equal( target[0].style.left, "", "left should not be modified" ); @@ -45,10 +45,10 @@ test("s", function() { var handle = ".ui-resizable-s", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, 0, 50); + resizableTestHelpers.drag(handle, 0, 50); equal( target.height(), 150, "compare height" ); - TestHelpers.resizable.drag(handle, 0, -50); + resizableTestHelpers.drag(handle, 0, -50); equal( target.height(), 100, "compare height" ); equal( target[0].style.top, "", "top should not be modified" ); @@ -61,10 +61,10 @@ test("e", function() { var handle = ".ui-resizable-e", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, 50); + resizableTestHelpers.drag(handle, 50); equal( target.width(), 150, "compare width"); - TestHelpers.resizable.drag(handle, -50); + resizableTestHelpers.drag(handle, -50); equal( target.width(), 100, "compare width" ); equal( target[0].style.height, "", "height should not be modified" ); @@ -77,10 +77,10 @@ test("w", function() { var handle = ".ui-resizable-w", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, -50); + resizableTestHelpers.drag(handle, -50); equal( target.width(), 150, "compare width" ); - TestHelpers.resizable.drag(handle, 50); + resizableTestHelpers.drag(handle, 50); equal( target.width(), 100, "compare width" ); equal( target[0].style.height, "", "height should not be modified" ); @@ -92,11 +92,11 @@ test("ne", function() { var handle = ".ui-resizable-ne", target = $("#resizable1").css({ overflow: "hidden" }).resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, -50, -50); + resizableTestHelpers.drag(handle, -50, -50); equal( target.width(), 50, "compare width" ); equal( target.height(), 150, "compare height" ); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -108,11 +108,11 @@ test("se", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal( target.width(), 150, "compare width" ); equal( target.height(), 150, "compare height" ); - TestHelpers.resizable.drag(handle, -50, -50); + resizableTestHelpers.drag(handle, -50, -50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -125,11 +125,11 @@ test("sw", function() { var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, -50, -50); + resizableTestHelpers.drag(handle, -50, -50); equal( target.width(), 150, "compare width" ); equal( target.height(), 50, "compare height" ); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -141,11 +141,11 @@ test("nw", function() { var handle = ".ui-resizable-nw", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, -50, -50); + resizableTestHelpers.drag(handle, -50, -50); equal( target.width(), 150, "compare width" ); equal( target.height(), 150, "compare height" ); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); }); @@ -163,10 +163,10 @@ test("handle with complex markup (#8756)", function() { var handle = ".ui-resizable-w div", target = $("#resizable1").resizable({ handles: "all" }); - TestHelpers.resizable.drag(handle, -50); + resizableTestHelpers.drag(handle, -50); equal( target.width(), 150, "compare width" ); - TestHelpers.resizable.drag(handle, 50); + resizableTestHelpers.drag(handle, 50); equal( target.width(), 100, "compare width" ); }); @@ -186,7 +186,7 @@ test("resizable accounts for scroll position correctly (#3815)", function() { left = el.css("left"); top = el.css("top"); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); deepEqual( el.position(), position, "position stays the same when resized" ); equal( el.css("left"), left, "css('left') stays the same when resized" ); equal( el.css("top"), top, "css('top') stays the same when resized" ); @@ -203,7 +203,7 @@ test( "resizable stores correct size when using helper and grid (#9547)", functi grid: [ 10, 10 ] }); - TestHelpers.resizable.drag( handle, 1, 1 ); + resizableTestHelpers.drag( handle, 1, 1 ); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); }); @@ -227,18 +227,18 @@ test( "nested resizable", function() { innerHandle = $( "#inner > .ui-resizable-e" ); outerHandle = $( "#outer > .ui-resizable-e" ); - TestHelpers.resizable.drag( innerHandle, 10 ); + resizableTestHelpers.drag( innerHandle, 10 ); equal( inner.width(), 40, "compare width of inner element" ); - TestHelpers.resizable.drag( innerHandle, -10 ); + resizableTestHelpers.drag( innerHandle, -10 ); equal( inner.width(), 30, "compare width of inner element" ); - TestHelpers.resizable.drag( outerHandle, 10 ); + resizableTestHelpers.drag( outerHandle, 10 ); equal( outer.width(), 60, "compare width of outer element" ); - TestHelpers.resizable.drag( outerHandle, -10 ); + resizableTestHelpers.drag( outerHandle, -10 ); equal( outer.width(), 50, "compare width of outer element" ); inner.remove(); outer.remove(); }); -})(jQuery); +} ); diff --git a/tests/unit/resizable/resizable_events.js b/tests/unit/resizable/resizable_events.js index d3851f72ed6..62f2582398c 100644 --- a/tests/unit/resizable/resizable_events.js +++ b/tests/unit/resizable/resizable_events.js @@ -1,7 +1,8 @@ -/* - * resizable_events.js - */ -(function($) { +define( [ + "jquery", + "./resizable_test_helpers", + "ui/resizable" +], function( $, resizableTestHelpers ) { module("resizable: events"); @@ -23,7 +24,7 @@ test("start", function() { } }); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal(count, 1, "start callback should happen exactly once"); @@ -54,7 +55,7 @@ test( "resize", function() { } }); - TestHelpers.resizable.drag( handle, 50, 50 ); + resizableTestHelpers.drag( handle, 50, 50 ); equal( count, 2, "resize callback should happen exactly once per size adjustment" ); @@ -82,7 +83,7 @@ test( "resize (min/max dimensions)", function() { } }); - TestHelpers.resizable.drag( handle, -200, -200 ); + resizableTestHelpers.drag( handle, -200, -200 ); equal( count, 1, "resize callback should happen exactly once per size adjustment" ); @@ -112,10 +113,10 @@ test( "resize (containment)", function() { }); // Prove you can't resize outside containment by dragging southeast corner southeast - TestHelpers.resizable.drag( handle, 100, 100 ); + resizableTestHelpers.drag( handle, 100, 100 ); // Prove you can't resize outside containment by dragging southeast corner northwest - TestHelpers.resizable.drag( handle, -200, -200 ); + resizableTestHelpers.drag( handle, -200, -200 ); equal( count, 1, "resize callback should happen exactly once per size adjustment" ); @@ -140,7 +141,7 @@ test("resize (grid)", function() { } }); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal(count, 1, "resize callback should happen exactly once per grid-unit size adjustment"); @@ -159,7 +160,7 @@ test( "resize, custom adjustment", function() { } }); - TestHelpers.resizable.drag( handle, 50, 50 ); + resizableTestHelpers.drag( handle, 50, 50 ); equal( element.width(), 100, "resize event can control width" ); equal( element.height(), 200, "resize event can control height" ); @@ -185,7 +186,7 @@ test("stop", function() { } }); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal(count, 1, "stop callback should happen exactly once"); @@ -230,7 +231,7 @@ test( "resize (containment) works with parent with negative offset", function() widthBefore = target.width(); - TestHelpers.resizable.drag( handle, increaseWidthBy, 0 ); + resizableTestHelpers.drag( handle, increaseWidthBy, 0 ); widthAfter = target.width(); @@ -238,4 +239,4 @@ test( "resize (containment) works with parent with negative offset", function() }); -})(jQuery); +} ); diff --git a/tests/unit/resizable/resizable_methods.js b/tests/unit/resizable/resizable_methods.js index 997293099f1..a7056a105eb 100644 --- a/tests/unit/resizable/resizable_methods.js +++ b/tests/unit/resizable/resizable_methods.js @@ -1,7 +1,7 @@ -/* - * resizable_methods.js - */ -(function($) { +define( [ + "jquery", + "ui/resizable" +], function( $ ) { module( "resizable: methods" ); @@ -18,4 +18,4 @@ test( "disable", function( assert ) { equal( chainable, element, "disable is chainable" ); }); -})(jQuery); +} ); diff --git a/tests/unit/resizable/resizable_options.js b/tests/unit/resizable/resizable_options.js index 6e3a93a2f85..c296fe38cf2 100644 --- a/tests/unit/resizable/resizable_options.js +++ b/tests/unit/resizable/resizable_options.js @@ -1,7 +1,8 @@ -/* - * resizable_options.js - */ -(function($) { +define( [ + "jquery", + "./resizable_test_helpers", + "ui/resizable" +], function( $, resizableTestHelpers ) { module("resizable: options"); @@ -19,7 +20,7 @@ test( "alsoResize", function() { }), handle = ".ui-resizable-e"; - TestHelpers.resizable.drag( handle, 80 ); + resizableTestHelpers.drag( handle, 80 ); equal( element.width(), 180, "resizable width" ); equal( other.width(), 130, "alsoResize width" ); }); @@ -29,11 +30,11 @@ test("aspectRatio: 'preserve' (e)", function() { var handle = ".ui-resizable-e", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, 80); + resizableTestHelpers.drag(handle, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, -130); + resizableTestHelpers.drag(handle, -130); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -43,11 +44,11 @@ test("aspectRatio: 'preserve' (w)", function() { var handle = ".ui-resizable-w", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, -80); + resizableTestHelpers.drag(handle, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, 130); + resizableTestHelpers.drag(handle, 130); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -57,11 +58,11 @@ test("aspectRatio: 'preserve' (n)", function() { var handle = ".ui-resizable-n", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, 0, -80); + resizableTestHelpers.drag(handle, 0, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, 0, 80); + resizableTestHelpers.drag(handle, 0, 80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -71,11 +72,11 @@ test("aspectRatio: 'preserve' (s)", function() { var handle = ".ui-resizable-s", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, 0, 80); + resizableTestHelpers.drag(handle, 0, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, 0, -80); + resizableTestHelpers.drag(handle, 0, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -85,11 +86,11 @@ test("aspectRatio: 'preserve' (se)", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, 80, 80); + resizableTestHelpers.drag(handle, 80, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, -80, -80); + resizableTestHelpers.drag(handle, -80, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -99,11 +100,11 @@ test("aspectRatio: 'preserve' (sw)", function() { var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, -80, 80); + resizableTestHelpers.drag(handle, -80, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, 80, -80); + resizableTestHelpers.drag(handle, 80, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -113,11 +114,11 @@ test("aspectRatio: 'preserve' (ne)", function() { var handle = ".ui-resizable-ne", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - TestHelpers.resizable.drag(handle, 80, -80); + resizableTestHelpers.drag(handle, 80, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - TestHelpers.resizable.drag(handle, -80, 80); + resizableTestHelpers.drag(handle, -80, 80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -137,7 +138,7 @@ test( "aspectRatio: Resizing can move objects", function() { $( "#container" ).css({ width: 200, height: 300 }); $( "#resizable1" ).css({ width: 100, height: 100, left: 75, top: 200 }); - TestHelpers.resizable.drag( handleW, -20 ); + resizableTestHelpers.drag( handleW, -20 ); equal( target.width(), 100, "compare width - no size change" ); equal( target.height(), 100, "compare height - no size change" ); equal( target.position().left, 75, "compare left - no movement" ); @@ -146,7 +147,7 @@ test( "aspectRatio: Resizing can move objects", function() { $( "#container" ).css({ width: 200, height: 300, position: "absolute", left: 100, top: 100 }); $( "#resizable1" ).css({ width: 100, height: 100, left: 0, top: 0 }); - TestHelpers.resizable.drag( handleNW, -20, -20 ); + resizableTestHelpers.drag( handleNW, -20, -20 ); equal( target.width(), 100, "compare width - no size change" ); equal( target.height(), 100, "compare height - no size change" ); equal( target.position().left, 0, "compare left - no movement" ); @@ -160,11 +161,11 @@ test( "containment", function() { containment: "#container" }); - TestHelpers.resizable.drag( ".ui-resizable-se", 20, 30 ); + resizableTestHelpers.drag( ".ui-resizable-se", 20, 30 ); equal( element.width(), 120, "unconstrained width within container" ); equal( element.height(), 130, "unconstrained height within container" ); - TestHelpers.resizable.drag( ".ui-resizable-se", 400, 400 ); + resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "constrained width at containment edge" ); equal( element.height(), 200, "constrained height at containment edge" ); }); @@ -179,10 +180,10 @@ test( "containment - not immediate parent", function() { handles: "all" }); - TestHelpers.resizable.drag( ".ui-resizable-e", 300, 0 ); + resizableTestHelpers.drag( ".ui-resizable-e", 300, 0 ); equal( element.width(), 400, "Relative, contained within container width" ); - TestHelpers.resizable.drag( ".ui-resizable-s", 0, 300 ); + resizableTestHelpers.drag( ".ui-resizable-s", 0, 300 ); equal( element.height(), 400, "Relative, contained within container height" ); $( "#child" ).css( { left: 50, top: 50 } ); @@ -194,10 +195,10 @@ test( "containment - not immediate parent", function() { handles: "all" }); - TestHelpers.resizable.drag( ".ui-resizable-e", 400, 0 ); + resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 300, "Relative with Left, contained within container width" ); - TestHelpers.resizable.drag( ".ui-resizable-s", 0, 400 ); + resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 300, "Relative with Top, contained within container height" ); }); @@ -211,10 +212,10 @@ test( "containment - immediate parent", function() { handles: "all" }); - TestHelpers.resizable.drag( ".ui-resizable-e", 400, 0 ); + resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 300, "Relative, contained within container width" ); - TestHelpers.resizable.drag( ".ui-resizable-s", 0, 400 ); + resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 300, "Relative, contained within container height" ); $( "#child" ).css( { left: 50, top: 50 } ); @@ -226,10 +227,10 @@ test( "containment - immediate parent", function() { handles: "all" }); - TestHelpers.resizable.drag( ".ui-resizable-e", 400, 0 ); + resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 250, "Relative with Left, contained within container width" ); - TestHelpers.resizable.drag( ".ui-resizable-s", 0, 400 ); + resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 250, "Relative with Top, contained within container height" ); }); @@ -238,11 +239,11 @@ test("grid", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", grid: [ 0, 20 ] }); - TestHelpers.resizable.drag(handle, 3, 9); + resizableTestHelpers.drag(handle, 3, 9); equal( target.width(), 103, "compare width"); equal( target.height(), 100, "compare height"); - TestHelpers.resizable.drag(handle, 15, 11); + resizableTestHelpers.drag(handle, 15, 11); equal( target.width(), 118, "compare width"); equal( target.height(), 120, "compare height"); }); @@ -252,11 +253,11 @@ test("grid (min/max dimensions)", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", grid: 20, minWidth: 65, minHeight: 65, maxWidth: 135, maxHeight: 135 }); - TestHelpers.resizable.drag(handle, 50, 50); + resizableTestHelpers.drag(handle, 50, 50); equal( target.width(), 120, "grid should respect maxWidth"); equal( target.height(), 120, "grid should respect maxHeight"); - TestHelpers.resizable.drag(handle, -100, -100); + resizableTestHelpers.drag(handle, -100, -100); equal( target.width(), 80, "grid should respect minWidth"); equal( target.height(), 80, "grid should respect minHeight"); }); @@ -266,11 +267,11 @@ test("grid (wrapped)", function() { var handle = ".ui-resizable-se", target = $("#resizable2").resizable({ handles: "all", grid: [ 0, 20 ] }); - TestHelpers.resizable.drag(handle, 3, 9); + resizableTestHelpers.drag(handle, 3, 9); equal( target.width(), 103, "compare width"); equal( target.height(), 100, "compare height"); - TestHelpers.resizable.drag(handle, 15, 11); + resizableTestHelpers.drag(handle, 15, 11); equal( target.width(), 118, "compare width"); equal( target.height(), 120, "compare height"); }); @@ -285,13 +286,13 @@ test( "grid - Resizable: can be moved when grid option is set (#9611)", function grid: 50 }); - TestHelpers.resizable.drag( handle, 50, 50 ); + resizableTestHelpers.drag( handle, 50, 50 ); equal( target.width(), 50, "compare width" ); equal( target.height(), 50, "compare height" ); oldPosition = target.position(); - TestHelpers.resizable.drag( handle, 50, 50 ); + resizableTestHelpers.drag( handle, 50, 50 ); equal( target.width(), 50, "compare width" ); equal( target.height(), 50, "compare height" ); equal( target.position().top, oldPosition.top, "compare top" ); @@ -313,7 +314,7 @@ test( "grid - maintains grid with padding and border when approaching no dimensi grid: [ 50, 12 ] }); - TestHelpers.resizable.drag( handle, 50, 50 ); + resizableTestHelpers.drag( handle, 50, 50 ); equal( target.outerWidth(), 50, "compare width" ); equal( target.outerHeight(), 52, "compare height" ); }); @@ -323,11 +324,11 @@ test("ui-resizable-se { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - TestHelpers.resizable.drag(handle, -50, -50); + resizableTestHelpers.drag(handle, -50, -50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - TestHelpers.resizable.drag(handle, 70, 70); + resizableTestHelpers.drag(handle, 70, 70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -337,11 +338,11 @@ test("ui-resizable-sw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - TestHelpers.resizable.drag(handle, 50, -50); + resizableTestHelpers.drag(handle, 50, -50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - TestHelpers.resizable.drag(handle, -70, 70); + resizableTestHelpers.drag(handle, -70, 70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -351,11 +352,11 @@ test("ui-resizable-ne { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-ne", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - TestHelpers.resizable.drag(handle, -50, 50); + resizableTestHelpers.drag(handle, -50, 50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - TestHelpers.resizable.drag(handle, 70, -70); + resizableTestHelpers.drag(handle, 70, -70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -365,11 +366,11 @@ test("ui-resizable-nw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-nw", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - TestHelpers.resizable.drag(handle, 70, 70); + resizableTestHelpers.drag(handle, 70, 70); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - TestHelpers.resizable.drag(handle, -70, -70); + resizableTestHelpers.drag(handle, -70, -70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -381,10 +382,10 @@ test( "custom handles { handles: { 's': $('#resizer1'), containment: 'parent' }" var handle = "#resizer1", target = $( "#resizable1" ).resizable({ handles: { "s": $( "#resizer1" ) }, containment: "parent" }); - TestHelpers.resizable.drag( handle, 0, 70 ); + resizableTestHelpers.drag( handle, 0, 70 ); equal( target.height(), 170, "compare height" ); - TestHelpers.resizable.drag( handle, 0, -70 ); + resizableTestHelpers.drag( handle, 0, -70 ); equal( target.height(), 100, "compare height" ); }); @@ -395,10 +396,10 @@ test( "custom handles { handles: { 's': $('#resizer1')[0], containment: 'parent' var handle = "#resizer1", target = $( "#resizable1" ).resizable({ handles: { "s": $( "#resizer1" )[ 0 ] }, containment: "parent" }); - TestHelpers.resizable.drag( handle, 0, 70 ); + resizableTestHelpers.drag( handle, 0, 70 ); equal( target.height(), 170, "compare height" ); - TestHelpers.resizable.drag( handle, 0, -70 ); + resizableTestHelpers.drag( handle, 0, -70 ); equal( target.height(), 100, "compare height" ); }); @@ -425,7 +426,7 @@ test( "alsoResize + containment", function() { containment: "#container" }); - TestHelpers.resizable.drag( ".ui-resizable-se", 400, 400 ); + resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "resizable constrained width at containment edge" ); equal( element.height(), 200, "resizable constrained height at containment edge" ); equal( other.width(), 250, "alsoResize constrained width at containment edge" ); @@ -453,7 +454,7 @@ test( "alsoResize + multiple selection", function() { containment: "#container" }); - TestHelpers.resizable.drag( ".ui-resizable-se", 400, 400 ); + resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "resizable constrained width at containment edge" ); equal( element.height(), 200, "resizable constrained height at containment edge" ); equal( other1.width(), 250, "alsoResize o1 constrained width at containment edge" ); @@ -462,4 +463,4 @@ test( "alsoResize + multiple selection", function() { equal( other2.height(), 150, "alsoResize o2 constrained height at containment edge" ); }); -})(jQuery); +} ); diff --git a/tests/unit/resizable/resizable_test_helpers.js b/tests/unit/resizable/resizable_test_helpers.js index cc0ef48ec3c..1c2ec831b5a 100644 --- a/tests/unit/resizable/resizable_test_helpers.js +++ b/tests/unit/resizable/resizable_test_helpers.js @@ -1,4 +1,6 @@ -TestHelpers.resizable = { +define( function() { + +return { drag: function( el, dx, dy ) { // this mouseover is to work around a limitation in resizable // TODO: fix resizable so handle doesn't require mouseover in order to be used @@ -9,3 +11,5 @@ TestHelpers.resizable = { }); } }; + +} ); From 64cebb2a0604d19561cd679dd2ea391439947318 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:38:11 -0400 Subject: [PATCH 13/29] Selectable: Convert tests to new infrastructure --- tests/unit/selectable/selectable.html | 27 ++------------------- tests/unit/selectable/selectable_common.js | 9 ++++++- tests/unit/selectable/selectable_events.js | 13 +++++----- tests/unit/selectable/selectable_methods.js | 10 ++++---- tests/unit/selectable/selectable_options.js | 10 ++++---- 5 files changed, 27 insertions(+), 42 deletions(-) diff --git a/tests/unit/selectable/selectable.html b/tests/unit/selectable/selectable.html index 024d2891178..4486084e4ba 100644 --- a/tests/unit/selectable/selectable.html +++ b/tests/unit/selectable/selectable.html @@ -4,31 +4,8 @@ jQuery UI Selectable Test Suite - - - - - - - - - - - - - - - + + diff --git a/tests/unit/selectable/selectable_common.js b/tests/unit/selectable/selectable_common.js index 79bf6e3c5dc..9a14e6df57c 100644 --- a/tests/unit/selectable/selectable_common.js +++ b/tests/unit/selectable/selectable_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests("selectable", { +define( [ + "lib/common", + "ui/selectable" +], function( common ) { + +common.testWidget( "selectable", { defaults: { appendTo: "body", autoRefresh: true, @@ -20,3 +25,5 @@ TestHelpers.commonWidgetTests("selectable", { unselecting: null } }); + +} ); diff --git a/tests/unit/selectable/selectable_events.js b/tests/unit/selectable/selectable_events.js index 5df7f2f5b25..6eb99f32535 100644 --- a/tests/unit/selectable/selectable_events.js +++ b/tests/unit/selectable/selectable_events.js @@ -1,7 +1,8 @@ -/* - * selectable_events.js - */ -(function( $ ) { +define( [ + "jquery", + "lib/helper", + "ui/selectable" +], function( $, testHelpers ) { module("selectable: events"); @@ -40,7 +41,7 @@ test( "mousedown: initial position of helper", function() { var helperOffset, element = $( "#selectable1" ).selectable(), - contentToForceScroll = TestHelpers.forceScrollableWindow( "body" ); + contentToForceScroll = testHelpers.forceScrollableWindow( "body" ); $( window ).scrollTop( 100 ).scrollLeft( 100 ); @@ -59,4 +60,4 @@ test( "mousedown: initial position of helper", function() { $( window ).scrollTop( 0 ).scrollLeft( 0 ); }); -})( jQuery ); +} ); diff --git a/tests/unit/selectable/selectable_methods.js b/tests/unit/selectable/selectable_methods.js index 02c9ab0752e..045809670dc 100644 --- a/tests/unit/selectable/selectable_methods.js +++ b/tests/unit/selectable/selectable_methods.js @@ -1,7 +1,7 @@ -/* - * selectable_methods.js - */ -(function($) { +define( [ + "jquery", + "ui/selectable" +], function( $ ) { module("selectable: methods"); @@ -108,4 +108,4 @@ test( "disable", function( assert ) { equal( chainable, element, "disable is chainable" ); }); -})(jQuery); +} ); diff --git a/tests/unit/selectable/selectable_options.js b/tests/unit/selectable/selectable_options.js index 292c0cf960b..cdbfb4aab2c 100644 --- a/tests/unit/selectable/selectable_options.js +++ b/tests/unit/selectable/selectable_options.js @@ -1,7 +1,7 @@ -/* - * selectable_options.js - */ -(function($) { +define( [ + "jquery", + "ui/selectable" +], function( $ ) { module("selectable: options"); @@ -61,4 +61,4 @@ test("filter", function() { el.selectable("destroy"); }); -})(jQuery); +} ); From eec2e912dfda8d2f74bb54af1f4b171efd05554d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:40:47 -0400 Subject: [PATCH 14/29] Selectmenu: Convert tests to new infrastructure --- tests/unit/selectmenu/selectmenu.html | 28 ++------------------- tests/unit/selectmenu/selectmenu_common.js | 9 ++++++- tests/unit/selectmenu/selectmenu_core.js | 7 ++++-- tests/unit/selectmenu/selectmenu_events.js | 7 ++++-- tests/unit/selectmenu/selectmenu_methods.js | 11 +++++--- tests/unit/selectmenu/selectmenu_options.js | 7 ++++-- 6 files changed, 32 insertions(+), 37 deletions(-) diff --git a/tests/unit/selectmenu/selectmenu.html b/tests/unit/selectmenu/selectmenu.html index c9a399ad548..0583733a0d0 100644 --- a/tests/unit/selectmenu/selectmenu.html +++ b/tests/unit/selectmenu/selectmenu.html @@ -4,32 +4,8 @@ jQuery UI Selectmenu Test Suite - - - - - - - - - - - - - - - + + diff --git a/tests/unit/selectmenu/selectmenu_common.js b/tests/unit/selectmenu/selectmenu_common.js index f741eaf27e0..b24b8dace85 100644 --- a/tests/unit/selectmenu/selectmenu_common.js +++ b/tests/unit/selectmenu/selectmenu_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "selectmenu", { +define( [ + "lib/common", + "ui/selectmenu" +], function( common ) { + +common.testWidget( "selectmenu", { defaults: { appendTo: null, classes: { @@ -25,3 +30,5 @@ TestHelpers.commonWidgetTests( "selectmenu", { select: null } }); + +} ); diff --git a/tests/unit/selectmenu/selectmenu_core.js b/tests/unit/selectmenu/selectmenu_core.js index c4e98775121..e5807817ee4 100644 --- a/tests/unit/selectmenu/selectmenu_core.js +++ b/tests/unit/selectmenu/selectmenu_core.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/selectmenu" +], function( $ ) { module( "selectmenu: core" ); @@ -326,4 +329,4 @@ $.each([ }); }); -})( jQuery ); +} ); diff --git a/tests/unit/selectmenu/selectmenu_events.js b/tests/unit/selectmenu/selectmenu_events.js index 3ab6e93bc68..d5c463fa910 100644 --- a/tests/unit/selectmenu/selectmenu_events.js +++ b/tests/unit/selectmenu/selectmenu_events.js @@ -1,4 +1,7 @@ -(function ( $ ) { +define( [ + "jquery", + "ui/selectmenu" +], function( $ ) { module( "selectmenu: events", { setup: function() { @@ -130,4 +133,4 @@ asyncTest( "select", function() { }); }); -})( jQuery ); +} ); diff --git a/tests/unit/selectmenu/selectmenu_methods.js b/tests/unit/selectmenu/selectmenu_methods.js index 8f5454b1588..8481e804e08 100644 --- a/tests/unit/selectmenu/selectmenu_methods.js +++ b/tests/unit/selectmenu/selectmenu_methods.js @@ -1,10 +1,13 @@ -(function( $ ) { +define( [ + "jquery", + "ui/selectmenu" +], function( $ ) { module( "selectmenu: methods" ); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 1 ); - domEqual( "#speed", function() { + assert.domEqual( "#speed", function() { $( "#speed" ).selectmenu().selectmenu( "destroy" ); }); }); @@ -183,4 +186,4 @@ test( "widget and menuWidget", function( assert ) { ok( menu.is( "ul.ui-menu" ), "Menu Widget: element and class" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/selectmenu/selectmenu_options.js b/tests/unit/selectmenu/selectmenu_options.js index 7ed841a90a8..deb7a6d3a1d 100644 --- a/tests/unit/selectmenu/selectmenu_options.js +++ b/tests/unit/selectmenu/selectmenu_options.js @@ -1,4 +1,7 @@ -(function ( $ ) { +define( [ + "jquery", + "ui/selectmenu" +], function( $ ) { module( "selectmenu: options" ); @@ -122,4 +125,4 @@ test( "width", function() { equal( button.outerWidth(), 300, "button width fills container" ); }); -})( jQuery ); +} ); From c51d81e77b7f8228e67b1bfee0adee6f7a443d34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:44:05 -0400 Subject: [PATCH 15/29] Slider: Convert tests to new infrastructure --- tests/unit/slider/slider.html | 27 ++------------------------- tests/unit/slider/slider_common.js | 9 ++++++++- tests/unit/slider/slider_core.js | 10 +++++----- tests/unit/slider/slider_events.js | 7 +++++-- tests/unit/slider/slider_methods.js | 11 +++++++---- tests/unit/slider/slider_options.js | 11 +++++++---- 6 files changed, 34 insertions(+), 41 deletions(-) diff --git a/tests/unit/slider/slider.html b/tests/unit/slider/slider.html index 38520c0730a..f19085fd46e 100644 --- a/tests/unit/slider/slider.html +++ b/tests/unit/slider/slider.html @@ -4,31 +4,8 @@ jQuery UI Slider Test Suite - - - - - - - - - - - - - - - + + diff --git a/tests/unit/slider/slider_common.js b/tests/unit/slider/slider_common.js index c4033e8a997..77004d159d8 100644 --- a/tests/unit/slider/slider_common.js +++ b/tests/unit/slider/slider_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "slider", { +define( [ + "lib/common", + "ui/slider" +], function( common ) { + +common.testWidget( "slider", { defaults: { animate: false, cancel: "input, textarea, button, select, option", @@ -26,3 +31,5 @@ TestHelpers.commonWidgetTests( "slider", { stop: null } }); + +} ); diff --git a/tests/unit/slider/slider_core.js b/tests/unit/slider/slider_core.js index fa86b2df461..797d5525c88 100644 --- a/tests/unit/slider/slider_core.js +++ b/tests/unit/slider/slider_core.js @@ -1,7 +1,7 @@ -(function( $ ) { -// -// Slider Test Helper Functions -// +define( [ + "jquery", + "ui/slider" +], function( $ ) { var element, options; @@ -306,4 +306,4 @@ test( "keydown LEFT on handle decreases value by step, not less than min", funct element.slider( "destroy" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/slider/slider_events.js b/tests/unit/slider/slider_events.js index cc5546a9f6f..0d22577f128 100644 --- a/tests/unit/slider/slider_events.js +++ b/tests/unit/slider/slider_events.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/slider" +], function( $ ) { module( "slider: events" ); @@ -202,4 +205,4 @@ test( "event data", function() { handles.eq( slideHandleIndex ).simulate( "drag", { dx: 10 } ); }); -})( jQuery ); +} ); diff --git a/tests/unit/slider/slider_methods.js b/tests/unit/slider/slider_methods.js index d2ef1d9cebc..bddafefca54 100644 --- a/tests/unit/slider/slider_methods.js +++ b/tests/unit/slider/slider_methods.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/slider" +], function( $ ) { module( "slider: methods" ); @@ -23,9 +26,9 @@ test( "init", function() { ok( true, "arbitrary option setter after init" ); }); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 1 ); - domEqual( "#slider1", function() { + assert.domEqual( "#slider1", function() { $( "#slider1" ).slider().slider( "destroy" ); }); }); @@ -110,4 +113,4 @@ test( "value", function() { // ok(false, "missing test - untested code is broken code." ); //}); -})( jQuery ); +} ); diff --git a/tests/unit/slider/slider_options.js b/tests/unit/slider/slider_options.js index dedfe78d3e6..923c3c1c9af 100644 --- a/tests/unit/slider/slider_options.js +++ b/tests/unit/slider/slider_options.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/slider" +], function( $ ) { var element, options; @@ -54,7 +57,7 @@ test( "max", function() { element.slider( options ); ok( element.slider( "option", "value" ) === options.value, "value option is not contained by max" ); ok( element.slider( "value" ) === options.max, "value method is contained by max" ); - + options = { max: 9, min: 1, @@ -65,7 +68,7 @@ test( "max", function() { element.slider( options ); ok( element.slider( "value" ) === 7, "value method is within max, edge Case" ); - + options.step = 2; element.slider( options ); @@ -343,4 +346,4 @@ test( "range", function( assert ) { element.slider( "destroy" ); }); -})( jQuery ); +} ); From a3222d144b9663d5568bc7605607cb253aedf009 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 14:50:39 -0400 Subject: [PATCH 16/29] Sortable: Convert tests to new infrastructure --- tests/unit/sortable/sortable.html | 29 ++------------------ tests/unit/sortable/sortable_common.js | 9 +++++- tests/unit/sortable/sortable_core.js | 14 +++++----- tests/unit/sortable/sortable_events.js | 14 ++++++---- tests/unit/sortable/sortable_methods.js | 23 ++++++++-------- tests/unit/sortable/sortable_options.js | 10 +++---- tests/unit/sortable/sortable_test_helpers.js | 6 +++- 7 files changed, 47 insertions(+), 58 deletions(-) diff --git a/tests/unit/sortable/sortable.html b/tests/unit/sortable/sortable.html index 49b347582e2..a4c94ba0da4 100644 --- a/tests/unit/sortable/sortable.html +++ b/tests/unit/sortable/sortable.html @@ -4,33 +4,8 @@ jQuery UI Sortable Test Suite - - - - - - - - - - - - - - - - + + #sortable, #sortable2 { position:relative; diff --git a/tests/unit/sortable/sortable_common.js b/tests/unit/sortable/sortable_common.js index dca26c75c92..ab43251ab67 100644 --- a/tests/unit/sortable/sortable_common.js +++ b/tests/unit/sortable/sortable_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "sortable", { +define( [ + "lib/common", + "ui/sortable" +], function( common ) { + +common.testWidget( "sortable", { defaults: { appendTo: "parent", axis: false, @@ -44,3 +49,5 @@ TestHelpers.commonWidgetTests( "sortable", { update: null } }); + +} ); diff --git a/tests/unit/sortable/sortable_core.js b/tests/unit/sortable/sortable_core.js index ac027486b05..0a750618410 100644 --- a/tests/unit/sortable/sortable_core.js +++ b/tests/unit/sortable/sortable_core.js @@ -1,8 +1,8 @@ -/* - * sortable_core.js - */ - -(function( $ ) { +define( [ + "jquery", + "./sortable_test_helpers", + "ui/sortable" +], function( $, sortableTestHelpers ) { module( "sortable: core" ); @@ -13,7 +13,7 @@ test( "#9314: Sortable: Items cannot be dragged directly into bottom position", connectWith: ".connectWith" }); - TestHelpers.sortable.sort( $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" ); + sortableTestHelpers.sort( $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" ); }); test( "ui-sortable-handle applied to appropriate element", function( assert ) { @@ -39,4 +39,4 @@ test( "ui-sortable-handle applied to appropriate element", function( assert ) { equal( el.find( ".ui-sortable-handle" ).length, 0, "class name removed on destroy" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/sortable/sortable_events.js b/tests/unit/sortable/sortable_events.js index 46e86c9060e..2bf9efe3042 100644 --- a/tests/unit/sortable/sortable_events.js +++ b/tests/unit/sortable/sortable_events.js @@ -1,7 +1,9 @@ -/* - * sortable_events.js - */ -(function($) { +define( [ + "jquery", + "./sortable_test_helpers", + "ui/sortable", + "ui/draggable" +], function( $, sortableTestHelpers ) { module("sortable: events"); @@ -170,7 +172,7 @@ test("#3019: Stop fires too early", function() { } }); - TestHelpers.sortable.sort($("li", el)[0], 0, 44, 2, "Dragging the sortable"); + sortableTestHelpers.sort($("li", el)[0], 0, 44, 2, "Dragging the sortable"); equal(helper, null, "helper should be false"); }); @@ -373,4 +375,4 @@ test("deactivate", function() { }); */ -})(jQuery); +} ); diff --git a/tests/unit/sortable/sortable_methods.js b/tests/unit/sortable/sortable_methods.js index 822bc082e1f..b1057fc8e7b 100644 --- a/tests/unit/sortable/sortable_methods.js +++ b/tests/unit/sortable/sortable_methods.js @@ -1,7 +1,8 @@ -/* - * sortable_methods.js - */ -(function($) { +define( [ + "jquery", + "./sortable_test_helpers", + "ui/sortable" +], function( $, sortableTestHelpers ) { module("sortable: methods"); @@ -47,7 +48,7 @@ test("enable", function() { el = $("#sortable").sortable({ disabled: true }); - TestHelpers.sortable.sort($("li", el)[0], 0, 44, 0, ".sortable({ disabled: true })"); + sortableTestHelpers.sort($("li", el)[0], 0, 44, 0, ".sortable({ disabled: true })"); el.sortable("enable"); equal(el.sortable("option", "disabled"), false, "disabled option getter"); @@ -57,7 +58,7 @@ test("enable", function() { el.sortable("option", "disabled", false); equal(el.sortable("option", "disabled"), false, "disabled option setter"); - TestHelpers.sortable.sort($("li", el)[0], 0, 44, 2, ".sortable('option', 'disabled', false)"); + sortableTestHelpers.sort($("li", el)[0], 0, 44, 2, ".sortable('option', 'disabled', false)"); expected = $("
").sortable(), actual = expected.sortable("enable"); @@ -70,15 +71,15 @@ test( "disable", function( assert ) { var chainable, element = $( "#sortable" ).sortable({ disabled: false }); - TestHelpers.sortable.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); + sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); chainable = element.sortable( "disable" ); - TestHelpers.sortable.sort( $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" ); + sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" ); element.sortable( "destroy" ); element.sortable({ disabled: false }); - TestHelpers.sortable.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); + sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); element.sortable( "option", "disabled", true); equal( element.sortable( "option", "disabled" ), true, "disabled option setter" ); @@ -86,7 +87,7 @@ test( "disable", function( assert ) { ok( !element.sortable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); assert.hasClasses( element.sortable( "widget" ), "ui-sortable-disabled" ); - TestHelpers.sortable.sort($( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" ); + sortableTestHelpers.sort($( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" ); equal( chainable, element, "disable is chainable" ); }); @@ -125,4 +126,4 @@ test( "refresh() should update the positions of initially empty lists (see #7498 equal( changeCount, 1 ); }); -})(jQuery); +} ); diff --git a/tests/unit/sortable/sortable_options.js b/tests/unit/sortable/sortable_options.js index 03308cb1877..930f339e677 100644 --- a/tests/unit/sortable/sortable_options.js +++ b/tests/unit/sortable/sortable_options.js @@ -1,7 +1,7 @@ -/* - * sortable_options.js - */ -(function($) { +define( [ + "jquery", + "ui/sortable" +], function( $ ) { module("sortable: options"); @@ -493,4 +493,4 @@ test("{ zIndex: false }", function() { ok(false, "missing test - untested code is broken code."); }); */ -})(jQuery); +} ); diff --git a/tests/unit/sortable/sortable_test_helpers.js b/tests/unit/sortable/sortable_test_helpers.js index 3cda43b8f5e..5f4f8aca69d 100644 --- a/tests/unit/sortable/sortable_test_helpers.js +++ b/tests/unit/sortable/sortable_test_helpers.js @@ -1,4 +1,6 @@ -TestHelpers.sortable = { +define( function() { + +return { sort: function( handle, dx, dy, index, msg ) { $( handle ).simulate( "drag", { dx: dx, @@ -7,3 +9,5 @@ TestHelpers.sortable = { equal( $( handle ).parent().children().index( handle ), index, msg ); } }; + +} ); From 69ed8abcf1442951e12f44db93143db3b76d6e64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 15:01:13 -0400 Subject: [PATCH 17/29] Tabs: Convert tests to new infrastructure --- tests/unit/tabs/tabs.html | 27 ++------------------------- tests/unit/tabs/tabs_common.js | 9 ++++++++- tests/unit/tabs/tabs_core.js | 10 +++++++--- tests/unit/tabs/tabs_events.js | 10 +++++++--- tests/unit/tabs/tabs_methods.js | 22 +++++++++++++--------- tests/unit/tabs/tabs_options.js | 14 +++++++++----- tests/unit/tabs/tabs_test_helpers.js | 6 +++++- 7 files changed, 51 insertions(+), 47 deletions(-) diff --git a/tests/unit/tabs/tabs.html b/tests/unit/tabs/tabs.html index e2bccec995d..6d52a2490bc 100644 --- a/tests/unit/tabs/tabs.html +++ b/tests/unit/tabs/tabs.html @@ -4,31 +4,8 @@ jQuery UI Tabs Test Suite - - - - - - - - - - - - - - - - + + #tabs8, #tabs8 * { margin: 0; diff --git a/tests/unit/tabs/tabs_common.js b/tests/unit/tabs/tabs_common.js index c43d8ff094b..d3aa5cd48ea 100644 --- a/tests/unit/tabs/tabs_common.js +++ b/tests/unit/tabs/tabs_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "tabs", { +define( [ + "lib/common", + "ui/tabs" +], function( common ) { + +common.testWidget( "tabs", { defaults: { active: null, classes: { @@ -22,3 +27,5 @@ TestHelpers.commonWidgetTests( "tabs", { load: null } }); + +} ); diff --git a/tests/unit/tabs/tabs_core.js b/tests/unit/tabs/tabs_core.js index 881571f5d2b..c7eb237044e 100644 --- a/tests/unit/tabs/tabs_core.js +++ b/tests/unit/tabs/tabs_core.js @@ -1,6 +1,10 @@ -(function( $ ) { +define( [ + "jquery", + "./tabs_test_helpers", + "ui/tabs" +], function( $, tabsTestHelpers ) { -var state = TestHelpers.tabs.state; +var state = tabsTestHelpers.state; module( "tabs: core" ); @@ -660,4 +664,4 @@ test( "#4033 - IE expands hash to full url and misinterprets tab as ajax", funct state( element, 1 ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tabs/tabs_events.js b/tests/unit/tabs/tabs_events.js index f9b1755f778..b5972242d53 100644 --- a/tests/unit/tabs/tabs_events.js +++ b/tests/unit/tabs/tabs_events.js @@ -1,6 +1,10 @@ -(function( $ ) { +define( [ + "jquery", + "./tabs_test_helpers", + "ui/tabs" +], function( $, tabsTestHelpers ) { -var state = TestHelpers.tabs.state; +var state = tabsTestHelpers.state; module( "tabs: events" ); @@ -315,4 +319,4 @@ asyncTest( "load", function() { } }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tabs/tabs_methods.js b/tests/unit/tabs/tabs_methods.js index b9b5bee9f5a..cd4ed3581e3 100644 --- a/tests/unit/tabs/tabs_methods.js +++ b/tests/unit/tabs/tabs_methods.js @@ -1,23 +1,27 @@ -(function( $ ) { +define( [ + "jquery", + "./tabs_test_helpers", + "ui/tabs" +], function( $, tabsTestHelpers ) { -var disabled = TestHelpers.tabs.disabled, - state = TestHelpers.tabs.state; +var disabled = tabsTestHelpers.disabled, + state = tabsTestHelpers.state; module( "tabs: methods" ); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 2 ); - domEqual( "#tabs1", function() { + assert.domEqual( "#tabs1", function() { $( "#tabs1" ).tabs().tabs( "destroy" ); }); - domEqual( "#tabs2", function() { + assert.domEqual( "#tabs2", function() { $( "#tabs2" ).tabs().tabs( "destroy" ); }); }); -asyncTest( "destroy - ajax", function() { +asyncTest( "destroy - ajax", function( assert ) { expect( 1 ); - domEqual( "#tabs2", function( done ) { + assert.domEqual( "#tabs2", function( done ) { var element = $( "#tabs2" ).tabs({ load: function() { setTimeout(function() { @@ -283,4 +287,4 @@ test( "widget", function() { strictEqual( widgetElement[ 0 ], element[ 0 ], "same element" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tabs/tabs_options.js b/tests/unit/tabs/tabs_options.js index 572ce3c20d1..13b88b040d0 100644 --- a/tests/unit/tabs/tabs_options.js +++ b/tests/unit/tabs/tabs_options.js @@ -1,8 +1,12 @@ -(function( $ ) { +define( [ + "jquery", + "./tabs_test_helpers", + "ui/tabs" +], function( $, tabsTestHelpers ) { -var disabled = TestHelpers.tabs.disabled, - equalHeight = TestHelpers.tabs.equalHeight, - state = TestHelpers.tabs.state; +var disabled = tabsTestHelpers.disabled, + equalHeight = tabsTestHelpers.equalHeight, + state = tabsTestHelpers.state; module( "tabs: options" ); @@ -367,4 +371,4 @@ asyncTest( "hide and show - animation", function() { element.tabs( "option", "active", 1 ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tabs/tabs_test_helpers.js b/tests/unit/tabs/tabs_test_helpers.js index 1be90f8fe97..8d35c31db40 100644 --- a/tests/unit/tabs/tabs_test_helpers.js +++ b/tests/unit/tabs/tabs_test_helpers.js @@ -1,4 +1,6 @@ -TestHelpers.tabs = { +define( function() { + +return { disabled: function( tabs, state ) { var expected, actual, internalState = tabs.tabs( "option", "disabled" ); @@ -64,3 +66,5 @@ TestHelpers.tabs = { deepEqual( actual, expected ); } }; + +} ); From e39eee200ec0c503a71d7f8ed5a6717eea184fff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 15:07:04 -0400 Subject: [PATCH 18/29] Widget: Convert tests to new infrastructure --- tests/unit/widget/widget.html | 28 ++++++++------------------- tests/unit/widget/widget_animation.js | 6 ++++++ tests/unit/widget/widget_classes.js | 11 +++++++---- tests/unit/widget/widget_core.js | 10 +++++++--- tests/unit/widget/widget_extend.js | 7 +++++-- 5 files changed, 33 insertions(+), 29 deletions(-) diff --git a/tests/unit/widget/widget.html b/tests/unit/widget/widget.html index ac106ea3294..8ccce85255e 100644 --- a/tests/unit/widget/widget.html +++ b/tests/unit/widget/widget.html @@ -4,27 +4,15 @@ jQuery UI Widget Test Suite - - - - - - - + - - - - - - - diff --git a/tests/unit/widget/widget_animation.js b/tests/unit/widget/widget_animation.js index 8ef55aa115c..4e9d93ccfde 100644 --- a/tests/unit/widget/widget_animation.js +++ b/tests/unit/widget/widget_animation.js @@ -1,3 +1,7 @@ +define( [ + "jquery", + "ui/widget" +], function( $ ) { module( "widget animation", (function() { var show = $.fn.show, @@ -255,3 +259,5 @@ asyncTest( "show: object(effect)", function() { next(); }); }); + +} ); diff --git a/tests/unit/widget/widget_classes.js b/tests/unit/widget/widget_classes.js index 0202d26831c..1b4a4512030 100644 --- a/tests/unit/widget/widget_classes.js +++ b/tests/unit/widget/widget_classes.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/widget" +], function( $ ) { module( "widget factory classes", { setup: function() { @@ -115,10 +118,10 @@ test( ".option() - classes setter", function( assert ) { "Appending a class to the current value works as expected" ); }); -test( ".destroy() - class removal", function() { +test( ".destroy() - class removal", function( assert ) { expect( 1 ); - domEqual( "#widget", function() { + assert.domEqual( "#widget", function() { $( "#widget" ).classesWidget().classesWidget( "destroy" ); }); }); @@ -140,4 +143,4 @@ test( "._add/_remove/_toggleClass()", function( assert ) { elementLacksClasses( widget, "remove", assert ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/widget/widget_core.js b/tests/unit/widget/widget_core.js index 74d6af9da0a..22832765bb1 100644 --- a/tests/unit/widget/widget_core.js +++ b/tests/unit/widget/widget_core.js @@ -1,4 +1,8 @@ -(function( $ ) { +define( [ + "jquery", + "lib/common", + "ui/widget" +], function( $, common ) { module( "widget factory", { teardown: function() { @@ -9,7 +13,7 @@ module( "widget factory", { } }); -TestHelpers.testJshint( "widget" ); +common.testJshint( "widget" ); test( "widget creation", function() { expect( 5 ); @@ -1507,4 +1511,4 @@ test( "$.widget.bridge() - widgetFullName", function() { equal( typeof instance, "object", "instance stored in .data(widgetFullName)" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/widget/widget_extend.js b/tests/unit/widget/widget_extend.js index f5d81bbdc73..a5a8cccaa81 100644 --- a/tests/unit/widget/widget_extend.js +++ b/tests/unit/widget/widget_extend.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/widget" +], function( $ ) { test( "$.widget.extend()", function() { expect( 27 ); @@ -106,4 +109,4 @@ test( "$.widget.extend()", function() { deepEqual( input, output, "don't clone arrays" ); }); -}( jQuery )); +} ); From 09813d0423064c8b5a08f9610f521c7e1bc5d817 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 19:46:15 -0400 Subject: [PATCH 19/29] Spinner: Convert tests to new infrastructure --- tests/lib/bootstrap.js | 3 +++ tests/unit/spinner/spinner.html | 30 ++-------------------- tests/unit/spinner/spinner_common.js | 9 ++++++- tests/unit/spinner/spinner_core.js | 10 +++++--- tests/unit/spinner/spinner_events.js | 10 +++++--- tests/unit/spinner/spinner_methods.js | 14 ++++++---- tests/unit/spinner/spinner_options.js | 9 +++++-- tests/unit/spinner/spinner_test_helpers.js | 6 ++++- 8 files changed, 48 insertions(+), 43 deletions(-) diff --git a/tests/lib/bootstrap.js b/tests/lib/bootstrap.js index c5e52057eef..94954ba3962 100644 --- a/tests/lib/bootstrap.js +++ b/tests/lib/bootstrap.js @@ -2,6 +2,8 @@ window.requirejs = { paths: { + "globalize": "../../../external/globalize/globalize", + "globalize/ja-JP": "../../../external/globalize/globalize.culture.ja-JP", "jquery": jqueryUrl(), "jquery-simulate": "../../../external/jquery-simulate/jquery.simulate", "jshint": "../../../external/jshint/jshint", @@ -12,6 +14,7 @@ window.requirejs = { "ui": "../../../ui" }, shim: { + "globalize/ja-JP": [ "globalize" ], "jquery-simulate": [ "jquery" ], "qunit-assert-classes": [ "qunit" ] } diff --git a/tests/unit/spinner/spinner.html b/tests/unit/spinner/spinner.html index c427f5de55c..43ded34a722 100644 --- a/tests/unit/spinner/spinner.html +++ b/tests/unit/spinner/spinner.html @@ -4,34 +4,8 @@ jQuery UI Spinner Test Suite - - - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/spinner/spinner_common.js b/tests/unit/spinner/spinner_common.js index 3eee4f9f076..2c40df76abb 100644 --- a/tests/unit/spinner/spinner_common.js +++ b/tests/unit/spinner/spinner_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "spinner", { +define( [ + "lib/common", + "ui/spinner" +], function( common ) { + +common.testWidget( "spinner", { defaults: { classes: { "ui-spinner": "ui-corner-all", @@ -26,3 +31,5 @@ TestHelpers.commonWidgetTests( "spinner", { stop: null } }); + +} ); diff --git a/tests/unit/spinner/spinner_core.js b/tests/unit/spinner/spinner_core.js index b3e1e6d2357..5faa733c35f 100644 --- a/tests/unit/spinner/spinner_core.js +++ b/tests/unit/spinner/spinner_core.js @@ -1,6 +1,10 @@ -(function( $ ) { +define( [ + "jquery", + "./spinner_test_helpers", + "ui/spinner" +], function( $, spinnerTestHelpers ) { -var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp; +var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; module( "spinner: core" ); @@ -250,4 +254,4 @@ test( "precision", function() { equal( element.val(), "0.05", "precision from min" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/spinner/spinner_events.js b/tests/unit/spinner/spinner_events.js index 007d34cf770..05d1efe1b72 100644 --- a/tests/unit/spinner/spinner_events.js +++ b/tests/unit/spinner/spinner_events.js @@ -1,6 +1,10 @@ -(function( $ ) { +define( [ + "jquery", + "./spinner_test_helpers", + "ui/spinner" +], function( $, spinnerTestHelpers ) { -var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp; +var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; module( "spinner: events" ); @@ -256,4 +260,4 @@ asyncTest( "change", function() { setTimeout( step1 ); }); -})( jQuery ); +} ); diff --git a/tests/unit/spinner/spinner_methods.js b/tests/unit/spinner/spinner_methods.js index 61ff21d1ca2..3f88a9e9c7f 100644 --- a/tests/unit/spinner/spinner_methods.js +++ b/tests/unit/spinner/spinner_methods.js @@ -1,12 +1,16 @@ -(function( $ ) { +define( [ + "jquery", + "./spinner_test_helpers", + "ui/spinner" +], function( $, spinnerTestHelpers ) { -var simulateKeyDownUp = TestHelpers.spinner.simulateKeyDownUp; +var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; module( "spinner: methods" ); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 1 ); - domEqual( "#spin", function() { + assert.domEqual( "#spin", function() { $( "#spin" ).spinner().spinner( "destroy" ); }); }); @@ -204,4 +208,4 @@ test( "widget", function() { strictEqual( widgetElement[ 0 ], element.parent()[ 0 ], "parent element" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/spinner/spinner_options.js b/tests/unit/spinner/spinner_options.js index 160b600c688..f8d9ad39695 100644 --- a/tests/unit/spinner/spinner_options.js +++ b/tests/unit/spinner/spinner_options.js @@ -1,4 +1,9 @@ -(function( $ ) { +define( [ + "jquery", + "ui/spinner", + "globalize", + "globalize/ja-JP" +], function( $ ) { module( "spinner: options" ); @@ -263,4 +268,4 @@ test( "step, string", function() { equal( element.val(), "$0.70", "stepUp" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/spinner/spinner_test_helpers.js b/tests/unit/spinner/spinner_test_helpers.js index 9b11cf6325f..9ed904ff451 100644 --- a/tests/unit/spinner/spinner_test_helpers.js +++ b/tests/unit/spinner/spinner_test_helpers.js @@ -1,7 +1,11 @@ -TestHelpers.spinner = { +define( function() { + +return { simulateKeyDownUp: function( element, keyCode, shift ) { element .simulate( "keydown", { keyCode: keyCode, shiftKey: shift || false } ) .simulate( "keyup", { keyCode: keyCode, shiftKey: shift || false } ); } }; + +} ); From 2f0ebade8f78c028f4ecdae0b58df8e58d0d2775 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:06:31 -0400 Subject: [PATCH 20/29] Datepicker: Convert tests to new infrastructure --- tests/unit/datepicker/datepicker.html | 28 +- tests/unit/datepicker/datepicker_core.js | 142 +++++----- tests/unit/datepicker/datepicker_events.js | 23 +- tests/unit/datepicker/datepicker_methods.js | 49 ++-- tests/unit/datepicker/datepicker_options.js | 253 +++++++++--------- .../datepicker/datepicker_test_helpers.js | 15 +- 6 files changed, 251 insertions(+), 259 deletions(-) diff --git a/tests/unit/datepicker/datepicker.html b/tests/unit/datepicker/datepicker.html index 136bd2f6b9b..a0df70d74ff 100644 --- a/tests/unit/datepicker/datepicker.html +++ b/tests/unit/datepicker/datepicker.html @@ -4,32 +4,8 @@ jQuery UI Datepicker Test Suite - - - - - - - - - - - - - - - + + diff --git a/tests/unit/datepicker/datepicker_core.js b/tests/unit/datepicker/datepicker_core.js index 65b07e2f6ca..3ed4b9487f3 100644 --- a/tests/unit/datepicker/datepicker_core.js +++ b/tests/unit/datepicker/datepicker_core.js @@ -1,8 +1,10 @@ -/* - * datepicker_core.js - */ - -(function($) { +define( [ + "jquery", + "lib/common", + "./datepicker_test_helpers", + "ui/datepicker", + "ui/i18n/datepicker-he" +], function( $, common, datepickerTestHelpers ) { module( "datepicker: core", { setup: function() { @@ -10,7 +12,7 @@ module( "datepicker: core", { } }); -TestHelpers.testJshint( "datepicker" ); +common.testJshint( "datepicker" ); test("initialization - Reinitialization after body had been emptied.", function() { expect( 1 ); @@ -37,11 +39,11 @@ test("widget method", function() { asyncTest( "baseStructure", function() { expect( 58 ); var header, title, table, thead, week, panel, inl, child, - inp = TestHelpers.datepicker.initNewInput(), + inp = datepickerTestHelpers.initNewInput(), dp = $( "#ui-datepicker-div" ); function step1() { - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ":visible" ), "Structure - datepicker visible" ); ok( !dp.is( ".ui-datepicker-rtl" ), "Structure - not right-to-left" ); ok( !dp.is( ".ui-datepicker-multi" ), "Structure - not multi-month" ); @@ -82,12 +84,12 @@ asyncTest( "baseStructure", function() { function step2() { // Editable month/year and button panel - inp = TestHelpers.datepicker.initNewInput({ + inp = datepickerTestHelpers.initNewInput({ changeMonth: true, changeYear: true, showButtonPanel: true }); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { title = dp.find( "div.ui-datepicker-title" ); ok( title.children( ":first" ).is( "select.ui-datepicker-month" ), "Structure - month selector" ); ok( title.children( ":last" ).is( "select.ui-datepicker-year" ), "Structure - year selector" ); @@ -105,8 +107,8 @@ asyncTest( "baseStructure", function() { function step3() { // Multi-month 2 - inp = TestHelpers.datepicker.initNewInput({ numberOfMonths: 2 }); - TestHelpers.datepicker.onFocus( inp, function() { + inp = datepickerTestHelpers.initNewInput({ numberOfMonths: 2 }); + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi" ), "Structure multi [2] - multi-month" ); equal( dp.children().length, 3, "Structure multi [2] - child count" ); @@ -127,8 +129,8 @@ asyncTest( "baseStructure", function() { function step4() { // Multi-month 3 - inp = TestHelpers.datepicker.initNewInput({ numberOfMonths: 3 }); - TestHelpers.datepicker.onFocus( inp, function() { + inp = datepickerTestHelpers.initNewInput({ numberOfMonths: 3 }); + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi-3" ), "Structure multi [3] - multi-3" ); ok( !dp.is( ".ui-datepicker-multi-2" ), "Structure multi [3] - Trac #6704" ); @@ -139,8 +141,8 @@ asyncTest( "baseStructure", function() { function step5() { // Multi-month [2, 2] - inp = TestHelpers.datepicker.initNewInput({ numberOfMonths: [ 2, 2 ] }); - TestHelpers.datepicker.onFocus( inp, function() { + inp = datepickerTestHelpers.initNewInput({ numberOfMonths: [ 2, 2 ] }); + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi" ), "Structure multi - multi-month" ); equal( dp.children().length, 6, "Structure multi [2,2] - child count" ); @@ -165,7 +167,7 @@ asyncTest( "baseStructure", function() { inp.datepicker( "hide" ).datepicker( "destroy" ); // Inline - inl = TestHelpers.datepicker.init( "#inl" ); + inl = datepickerTestHelpers.init( "#inl" ); dp = inl.children(); ok( dp.is( ".ui-datepicker-inline" ), "Structure inline - main div" ); @@ -185,7 +187,7 @@ asyncTest( "baseStructure", function() { inl.datepicker( "destroy" ); // Inline multi-month - inl = TestHelpers.datepicker.init( "#inl", { numberOfMonths: 2 } ); + inl = datepickerTestHelpers.init( "#inl", { numberOfMonths: 2 } ); dp = inl.children(); ok( dp.is( ".ui-datepicker-inline" ) && dp.is( ".ui-datepicker-multi" ), "Structure inline multi - main div" ); @@ -211,13 +213,13 @@ asyncTest( "baseStructure", function() { asyncTest( "customStructure", function() { expect( 20 ); var header, panel, title, thead, - inp = TestHelpers.datepicker.initNewInput( $.datepicker.regional.he ), + inp = datepickerTestHelpers.initNewInput( $.datepicker.regional.he ), dp = $( "#ui-datepicker-div" ); function step1() { inp.datepicker( "option", "showButtonPanel", true ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-rtl" ), "Structure RTL - right-to-left" ); header = dp.children( ":first" ); @@ -239,14 +241,14 @@ asyncTest( "customStructure", function() { // Hide prev/next function step2() { - inp = TestHelpers.datepicker.initNewInput({ + inp = datepickerTestHelpers.initNewInput({ hideIfNoPrevNext: true, minDate: new Date( 2008, 2 - 1, 4 ), maxDate: new Date( 2008, 2 - 1, 14 ) }); inp.val( "02/10/2008" ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { header = dp.children( ":first" ); ok( header.is( "div.ui-datepicker-header" ), "Structure hide prev/next - header division" ); equal( header.children().length, 1, "Structure hide prev/next - links child count" ); @@ -259,9 +261,9 @@ asyncTest( "customStructure", function() { // Changeable Month with read-only year function step3() { - inp = TestHelpers.datepicker.initNewInput({ changeMonth: true }); + inp = datepickerTestHelpers.initNewInput({ changeMonth: true }); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { title = dp.children( ":first" ).children( ":last" ); equal( title.children().length, 2, "Structure changeable month - title child count" ); ok( title.children( ":first" ).is( "select.ui-datepicker-month" ), "Structure changeable month - month selector" ); @@ -274,9 +276,9 @@ asyncTest( "customStructure", function() { // Changeable year with read-only month function step4() { - inp = TestHelpers.datepicker.initNewInput({ changeYear: true }); + inp = datepickerTestHelpers.initNewInput({ changeYear: true }); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { title = dp.children( ":first" ).children( ":last" ); equal( title.children().length, 2, "Structure changeable year - title child count" ); ok( title.children( ":first" ).is( "span.ui-datepicker-month" ), "Structure changeable year - read-only month" ); @@ -289,9 +291,9 @@ asyncTest( "customStructure", function() { // Read-only first day of week function step5() { - inp = TestHelpers.datepicker.initNewInput({ changeFirstDay: false }); + inp = datepickerTestHelpers.initNewInput({ changeFirstDay: false }); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { thead = dp.find( ".ui-datepicker-calendar thead tr" ); equal( thead.children().length, 7, "Structure read-only first day - thead child count" ); equal( thead.find( "a" ).length, 0, "Structure read-only first day - thead links count" ); @@ -309,19 +311,19 @@ asyncTest( "customStructure", function() { test("keystrokes", function() { expect( 26 ); - var inp = TestHelpers.datepicker.init("#inp"), + var inp = datepickerTestHelpers.init("#inp"), date = new Date(); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke enter"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke enter"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke enter - preset"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.HOME}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+home"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+home"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.END}); ok(inp.datepicker("getDate") == null, "Keystroke ctrl+end"); @@ -330,95 +332,95 @@ test("keystrokes", function() { ok(inp.datepicker("getDate") == null, "Keystroke esc"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke esc - preset"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke esc - abandoned"); // Moving by day or week inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.LEFT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+left"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+left"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.LEFT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke left"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke left"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.RIGHT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+right"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+right"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.RIGHT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke right"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke right"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 7); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+up"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+up"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 7); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke up"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke up"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 7); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+down"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+down"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 7); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Keystroke down"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke down"); // Moving by month or year inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 4), "Keystroke pgup"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 4), "Keystroke pgdn"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 4), "Keystroke ctrl+pgup"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 4), "Keystroke ctrl+pgdn"); // Check for moving to short months inp.val("03/31/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), "Keystroke pgup - Feb"); inp.val("01/30/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), "Keystroke pgdn - Feb"); inp.val("02/29/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 28), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 28), "Keystroke ctrl+pgup - Feb"); inp.val("02/29/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 28), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 28), "Keystroke ctrl+pgdn - Feb"); // Goto current inp.datepicker("option", {gotoCurrent: true}). @@ -426,35 +428,35 @@ test("keystrokes", function() { simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.HOME}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke ctrl+home"); // Change steps inp.datepicker("option", {stepMonths: 2, gotoCurrent: false}). datepicker("hide").val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2007, 12 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 12 - 1, 4), "Keystroke pgup step 2"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 4 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 4 - 1, 4), "Keystroke pgdn step 2"); }); test("mouse", function() { expect( 15 ); var inl, - inp = TestHelpers.datepicker.init("#inp"), + inp = datepickerTestHelpers.init("#inp"), dp = $("#ui-datepicker-div"), date = new Date(); inp.val("").datepicker("show"); $(".ui-datepicker-calendar tbody a:contains(10)", dp).simulate("click", {}); date.setDate(10); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Mouse click"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Mouse click"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-calendar tbody a:contains(12)", dp).simulate("click", {}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 12), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click - preset"); inp.val("02/04/2008").datepicker("show"); inp.val("").datepicker("show"); @@ -462,67 +464,67 @@ test("mouse", function() { ok(inp.datepicker("getDate") == null, "Mouse click - close"); inp.val("02/04/2008").datepicker("show"); $("button.ui-datepicker-close", dp).simulate("click", {}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Mouse click - close + preset"); inp.val("02/04/2008").datepicker("show"); $("a.ui-datepicker-prev", dp).simulate("click", {}); $("button.ui-datepicker-close", dp).simulate("click", {}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Mouse click - abandoned"); // Current/previous/next inp.val("02/04/2008").datepicker("option", {showButtonPanel: true}).datepicker("show"); $(".ui-datepicker-current", dp).simulate("click", {}); $(".ui-datepicker-calendar tbody a:contains(14)", dp).simulate("click", {}); date.setDate(14); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Mouse click - current"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Mouse click - current"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 16), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 16), "Mouse click - previous"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 18), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 18), "Mouse click - next"); // Previous/next with minimum/maximum inp.datepicker("option", {minDate: new Date(2008, 2 - 1, 2), maxDate: new Date(2008, 2 - 1, 26)}).val("02/04/2008").datepicker("show"); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 16), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 16), "Mouse click - previous + min/max"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 18), + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 18), "Mouse click - next + min/max"); // Inline - inl = TestHelpers.datepicker.init("#inl"); + inl = datepickerTestHelpers.init("#inl"); dp = $(".ui-datepicker-inline", inl); date = new Date(); inl.datepicker("setDate", date); $(".ui-datepicker-calendar tbody a:contains(10)", dp).simulate("click", {}); date.setDate(10); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline"); inl.datepicker("option", {showButtonPanel: true}).datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-calendar tbody a:contains(12)", dp).simulate("click", {}); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click inline - preset"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click inline - preset"); inl.datepicker("option", {showButtonPanel: true}); $(".ui-datepicker-current", dp).simulate("click", {}); $(".ui-datepicker-calendar tbody a:contains(14)", dp).simulate("click", {}); date.setDate(14); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline - current"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline - current"); inl.datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), new Date(2008, 1 - 1, 16), + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 1 - 1, 16), "Mouse click inline - previous"); inl.datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), new Date(2008, 3 - 1, 18), + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 3 - 1, 18), "Mouse click inline - next"); }); -})(jQuery); +} ); diff --git a/tests/unit/datepicker/datepicker_events.js b/tests/unit/datepicker/datepicker_events.js index dfc42ccf911..b012f647d41 100644 --- a/tests/unit/datepicker/datepicker_events.js +++ b/tests/unit/datepicker/datepicker_events.js @@ -1,7 +1,8 @@ -/* - * datepicker_events.js - */ -(function($) { +define( [ + "jquery", + "./datepicker_test_helpers", + "ui/datepicker" +], function( $, datepickerTestHelpers ) { module("datepicker: events"); @@ -24,13 +25,13 @@ function callback2(year, month, inst) { test("events", function() { expect( 26 ); var dateStr, newMonthYear, inp2, - inp = TestHelpers.datepicker.init("#inp", {onSelect: callback}), + inp = datepickerTestHelpers.init("#inp", {onSelect: callback}), date = new Date(); // onSelect inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); equal(selectedThis, inp[0], "Callback selected this"); - equal(selectedInst, $.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Callback selected inst"); + equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback selected inst"); equal(selectedDate, $.datepicker.formatDate("mm/dd/yy", date), "Callback selected date"); inp.val("").datepicker("show"). @@ -59,7 +60,7 @@ test("events", function() { inp.simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}); date.setMonth(date.getMonth() - 1); equal(selectedThis, inp[0], "Callback change month/year this"); - equal(selectedInst, $.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Callback change month/year inst"); + equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback change month/year inst"); equal(selectedDate, newMonthYear(date), "Callback change month/year date - pgup"); inp.simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}); @@ -107,7 +108,7 @@ test("events", function() { val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); equal(selectedThis, inp[0], "Callback close this"); - equal(selectedInst, $.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Callback close inst"); + equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback close inst"); equal(selectedDate, "", "Callback close date - esc"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); @@ -120,7 +121,7 @@ test("events", function() { simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.END}); equal(selectedDate, "", "Callback close date - ctrl+end"); - inp2 = TestHelpers.datepicker.init("#inp2"); + inp2 = datepickerTestHelpers.init("#inp2"); inp2.datepicker().datepicker("option", {onClose: callback}).datepicker("show"); inp.datepicker("show"); equal(selectedThis, inp2[0], "Callback close this"); @@ -128,7 +129,7 @@ test("events", function() { test("beforeShowDay-getDate", function() { expect( 3 ); - var inp = TestHelpers.datepicker.init("#inp", {beforeShowDay: function() { inp.datepicker("getDate"); return [true, ""]; }}), + var inp = datepickerTestHelpers.init("#inp", {beforeShowDay: function() { inp.datepicker("getDate"); return [true, ""]; }}), dp = $("#ui-datepicker-div"); inp.val("01/01/2010").datepicker("show"); // contains non-breaking space @@ -150,4 +151,4 @@ test("beforeShowDay-getDate", function() { inp.datepicker("hide"); }); -})(jQuery); +} ); diff --git a/tests/unit/datepicker/datepicker_methods.js b/tests/unit/datepicker/datepicker_methods.js index e52e126d2e6..c16376880aa 100644 --- a/tests/unit/datepicker/datepicker_methods.js +++ b/tests/unit/datepicker/datepicker_methods.js @@ -1,72 +1,73 @@ -/* - * datepicker_methods.js - */ -(function($) { +define( [ + "jquery", + "./datepicker_test_helpers", + "ui/datepicker" +], function( $, datepickerTestHelpers ) { module("datepicker: methods"); test("destroy", function() { expect( 33 ); var inl, - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); ok(inp.is(".hasDatepicker"), "Default - marker class set"); - ok($.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Default - instance present"); + ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Default - instance present"); ok(inp.next().is("#alt"), "Default - button absent"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Default - marker class cleared"); - ok(!$.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Default - instance absent"); + ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Default - instance absent"); ok(inp.next().is("#alt"), "Default - button absent"); // With button - inp= TestHelpers.datepicker.init("#inp", {showOn: "both"}); + inp= datepickerTestHelpers.init("#inp", {showOn: "both"}); ok(inp.is(".hasDatepicker"), "Button - marker class set"); - ok($.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Button - instance present"); + ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Button - instance present"); ok(inp.next().text() === "...", "Button - button added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Button - marker class cleared"); - ok(!$.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Button - instance absent"); + ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Button - instance absent"); ok(inp.next().is("#alt"), "Button - button removed"); // With append text - inp = TestHelpers.datepicker.init("#inp", {appendText: "Testing"}); + inp = datepickerTestHelpers.init("#inp", {appendText: "Testing"}); ok(inp.is(".hasDatepicker"), "Append - marker class set"); - ok($.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Append - instance present"); + ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Append - instance present"); ok(inp.next().text() === "Testing", "Append - append text added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Append - marker class cleared"); - ok(!$.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Append - instance absent"); + ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Append - instance absent"); ok(inp.next().is("#alt"), "Append - append text removed"); // With both - inp= TestHelpers.datepicker.init("#inp", {showOn: "both", buttonImageOnly: true, + inp= datepickerTestHelpers.init("#inp", {showOn: "both", buttonImageOnly: true, buttonImage: "images/calendar.gif", appendText: "Testing"}); ok(inp.is(".hasDatepicker"), "Both - marker class set"); - ok($.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Both - instance present"); + ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Both - instance present"); ok(inp.next()[0].nodeName.toLowerCase() === "img", "Both - button added"); ok(inp.next().next().text() === "Testing", "Both - append text added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Both - marker class cleared"); - ok(!$.data(inp[0], TestHelpers.datepicker.PROP_NAME), "Both - instance absent"); + ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Both - instance absent"); ok(inp.next().is("#alt"), "Both - button and append text absent"); // Inline - inl = TestHelpers.datepicker.init("#inl"); + inl = datepickerTestHelpers.init("#inl"); ok(inl.is(".hasDatepicker"), "Inline - marker class set"); ok(inl.html() !== "", "Inline - datepicker present"); - ok($.data(inl[0], TestHelpers.datepicker.PROP_NAME), "Inline - instance present"); + ok($.data(inl[0], datepickerTestHelpers.PROP_NAME), "Inline - instance present"); ok(inl.next().length === 0 || inl.next().is("p"), "Inline - button absent"); inl.datepicker("destroy"); inl = $("#inl"); ok(!inl.is(".hasDatepicker"), "Inline - marker class cleared"); ok(inl.html() === "", "Inline - datepicker absent"); - ok(!$.data(inl[0], TestHelpers.datepicker.PROP_NAME), "Inline - instance absent"); + ok(!$.data(inl[0], datepickerTestHelpers.PROP_NAME), "Inline - instance absent"); ok(inl.next().length === 0 || inl.next().is("p"), "Inline - button absent"); }); test("enableDisable", function() { expect( 33 ); var inl, dp, - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); ok(!inp.datepicker("isDisabled"), "Enable/disable - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable - field initially enabled"); inp.datepicker("disable"); @@ -77,7 +78,7 @@ test("enableDisable", function() { ok(!inp[0].disabled, "Enable/disable - field now enabled"); inp.datepicker("destroy"); // With a button - inp = TestHelpers.datepicker.init("#inp", {showOn: "button"}); + inp = datepickerTestHelpers.init("#inp", {showOn: "button"}); ok(!inp.datepicker("isDisabled"), "Enable/disable button - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable button - field initially enabled"); ok(!inp.next("button")[0].disabled, "Enable/disable button - button initially enabled"); @@ -91,7 +92,7 @@ test("enableDisable", function() { ok(!inp.next("button")[0].disabled, "Enable/disable button - button now enabled"); inp.datepicker("destroy"); // With an image button - inp = TestHelpers.datepicker.init("#inp", {showOn: "button", buttonImageOnly: true, + inp = datepickerTestHelpers.init("#inp", {showOn: "button", buttonImageOnly: true, buttonImage: "images/calendar.gif"}); ok(!inp.datepicker("isDisabled"), "Enable/disable image - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable image - field initially enabled"); @@ -106,7 +107,7 @@ test("enableDisable", function() { ok(parseFloat(inp.next("img").css("opacity")) === 1, "Enable/disable image - image now enabled"); inp.datepicker("destroy"); // Inline - inl = TestHelpers.datepicker.init("#inl", {changeYear: true}); + inl = datepickerTestHelpers.init("#inl", {changeYear: true}); dp = $(".ui-datepicker-inline", inl); ok(!inl.datepicker("isDisabled"), "Enable/disable inline - initially marked as enabled"); ok(!dp.children().is(".ui-state-disabled"), "Enable/disable inline - not visually disabled initially"); @@ -122,4 +123,4 @@ test("enableDisable", function() { inl.datepicker("destroy"); }); -})(jQuery); +} ); diff --git a/tests/unit/datepicker/datepicker_options.js b/tests/unit/datepicker/datepicker_options.js index 08c31f5ad4a..20a7b4d80b8 100644 --- a/tests/unit/datepicker/datepicker_options.js +++ b/tests/unit/datepicker/datepicker_options.js @@ -1,14 +1,17 @@ -/* - * datepicker_options.js - */ - -(function($) { +define( [ + "jquery", + "./datepicker_test_helpers", + "ui/datepicker", + "ui/i18n/datepicker-fr", + "ui/i18n/datepicker-he", + "ui/i18n/datepicker-zh-CN" +], function( $, datepickerTestHelpers ) { module("datepicker: options"); test("setDefaults", function() { expect( 3 ); - TestHelpers.datepicker.init("#inp"); + datepickerTestHelpers.init("#inp"); equal($.datepicker._defaults.showOn, "focus", "Initial showOn"); $.datepicker.setDefaults({showOn: "button"}); equal($.datepicker._defaults.showOn, "button", "Change default showOn"); @@ -18,8 +21,8 @@ test("setDefaults", function() { test("option", function() { expect( 17 ); - var inp = TestHelpers.datepicker.init("#inp"), - inst = $.data(inp[0], TestHelpers.datepicker.PROP_NAME); + var inp = datepickerTestHelpers.init("#inp"), + inst = $.data(inp[0], datepickerTestHelpers.PROP_NAME); // Set option equal(inst.settings.showOn, null, "Initial setting showOn"); equal($.datepicker._get(inst, "showOn"), "focus", "Initial instance showOn"); @@ -37,7 +40,7 @@ test("option", function() { equal($.datepicker._get(inst, "showOn"), "focus", "Restore instance showOn"); equal($.datepicker._defaults.showOn, "focus", "Retain default showOn"); // Get option - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); equal(inp.datepicker("option", "showOn"), "focus", "Initial setting showOn"); inp.datepicker("option", "showOn", "button"); equal(inp.datepicker("option", "showOn"), "button", "Change instance showOn"); @@ -50,7 +53,7 @@ test("option", function() { test( "disabled", function() { expect(8); - var inp = TestHelpers.datepicker.init("#inp"); + var inp = datepickerTestHelpers.init("#inp"); ok(!inp.datepicker("isDisabled"), "Initially marked as enabled"); ok(!inp[0].disabled, "Field initially enabled"); inp.datepicker("option", "disabled", true); @@ -61,15 +64,15 @@ test( "disabled", function() { ok(!inp[0].disabled, "Field now enabled"); inp.datepicker("destroy"); - inp = TestHelpers.datepicker.init("#inp", { disabled: true }); + inp = datepickerTestHelpers.init("#inp", { disabled: true }); ok(inp.datepicker("isDisabled"), "Initially marked as disabled"); ok(inp[0].disabled, "Field initially disabled"); }); test("change", function() { expect( 12 ); - var inp = TestHelpers.datepicker.init("#inp"), - inst = $.data(inp[0], TestHelpers.datepicker.PROP_NAME); + var inp = datepickerTestHelpers.init("#inp"), + inst = $.data(inp[0], datepickerTestHelpers.PROP_NAME); equal(inst.settings.showOn, null, "Initial setting showOn"); equal($.datepicker._get(inst, "showOn"), "focus", "Initial instance showOn"); equal($.datepicker._defaults.showOn, "focus", "Initial default showOn"); @@ -104,7 +107,7 @@ test("change", function() { expect( isOldIE ? 25 : 29 ); function step0() { - var inp = TestHelpers.datepicker.initNewInput(), + var inp = datepickerTestHelpers.initNewInput(), dp = $( "#ui-datepicker-div" ); button = inp.siblings( "button" ); @@ -112,7 +115,7 @@ test("change", function() { image = inp.siblings( "img" ); ok( image.length === 0, "Focus - image absent" ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ":visible" ), "Focus - rendered on focus" ); inp.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } ); ok( !dp.is( ":visible" ), "Focus - hidden on exit" ); @@ -122,10 +125,10 @@ test("change", function() { function step1() { - var inp = TestHelpers.datepicker.initNewInput(), + var inp = datepickerTestHelpers.initNewInput(), dp = $( "#ui-datepicker-div" ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ":visible" ), "Focus - rendered on focus" ); body.simulate( "mousedown", {} ); ok( !dp.is( ":visible" ), "Focus - hidden on external click" ); @@ -136,7 +139,7 @@ test("change", function() { } function step2() { - var inp = TestHelpers.datepicker.initNewInput({ + var inp = datepickerTestHelpers.initNewInput({ showOn: "button", buttonText: "Popup" }), @@ -149,7 +152,7 @@ test("change", function() { ok( image.length === 0, "Button - image absent" ); equal( button.text(), "Popup", "Button - button text" ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( !dp.is( ":visible" ), "Button - not rendered on focus" ); button.click(); ok( dp.is( ":visible" ), "Button - rendered on button click" ); @@ -162,7 +165,7 @@ test("change", function() { } function step3() { - var inp = TestHelpers.datepicker.initNewInput({ + var inp = datepickerTestHelpers.initNewInput({ showOn: "button", buttonImageOnly: true, buttonImage: "images/calendar.gif", @@ -178,7 +181,7 @@ test("change", function() { ok( /images\/calendar\.gif$/.test( image.attr( "src" ) ), "Image button - image source" ); equal( image.attr( "title" ), "Cal", "Image button - image text" ); - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( !dp.is( ":visible" ), "Image button - not rendered on focus" ); image.click(); ok( dp.is( ":visible" ), "Image button - rendered on image click" ); @@ -191,7 +194,7 @@ test("change", function() { } function step4() { - var inp = TestHelpers.datepicker.initNewInput({ + var inp = datepickerTestHelpers.initNewInput({ showOn: "both", buttonImage: "images/calendar.gif" }), @@ -207,7 +210,7 @@ test("change", function() { // TODO: This test occasionally fails to focus in IE8 in BrowserStack if ( !isOldIE ) { - TestHelpers.datepicker.onFocus( inp, function() { + datepickerTestHelpers.onFocus( inp, function() { ok( dp.is( ":visible" ), "Both - rendered on focus" ); body.simulate( "mousedown", {} ); ok( !dp.is( ":visible" ), "Both - hidden on external click" ); @@ -230,7 +233,7 @@ test("change", function() { test("otherMonths", function() { expect( 8 ); - var inp = TestHelpers.datepicker.init("#inp"), + var inp = datepickerTestHelpers.init("#inp"), pop = $("#ui-datepicker-div"); inp.val("06/01/2009").datepicker("show"); equal(pop.find("tbody").text(), @@ -258,105 +261,105 @@ test("otherMonths", function() { test("defaultDate", function() { expect( 16 ); - var inp = TestHelpers.datepicker.init("#inp"), + var inp = datepickerTestHelpers.init("#inp"), date = new Date(); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date null"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date null"); // Numeric values inp.datepicker("option", {defaultDate: -2}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date -2"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2"); date = new Date(); inp.datepicker("option", {defaultDate: 3}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 3); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date 3"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 3"); date = new Date(); inp.datepicker("option", {defaultDate: 1 / "a"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date NaN"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date NaN"); // String offset values inp.datepicker("option", {defaultDate: "-1d"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date -1d"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -1d"); inp.datepicker("option", {defaultDate: "+3D"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 4); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date +3D"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +3D"); inp.datepicker("option", {defaultDate: " -2 w "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(); date.setDate(date.getDate() - 14); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date -2 w"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2 w"); inp.datepicker("option", {defaultDate: "+1 W"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 21); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date +1 W"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1 W"); inp.datepicker("option", {defaultDate: " -1 m "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = TestHelpers.datepicker.addMonths(new Date(), -1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date -1 m"); + date = datepickerTestHelpers.addMonths(new Date(), -1); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -1 m"); inp.datepicker("option", {defaultDate: "+2M"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = TestHelpers.datepicker.addMonths(new Date(), 2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date +2M"); + date = datepickerTestHelpers.addMonths(new Date(), 2); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +2M"); inp.datepicker("option", {defaultDate: "-2y"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(); date.setFullYear(date.getFullYear() - 2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date -2y"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2y"); inp.datepicker("option", {defaultDate: "+1 Y "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setFullYear(date.getFullYear() + 3); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date +1 Y"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1 Y"); inp.datepicker("option", {defaultDate: "+1M +10d"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = TestHelpers.datepicker.addMonths(new Date(), 1); + date = datepickerTestHelpers.addMonths(new Date(), 1); date.setDate(date.getDate() + 10); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date +1M +10d"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1M +10d"); // String date values inp.datepicker("option", {defaultDate: "07/04/2007"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(2007, 7 - 1, 4); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date 07/04/2007"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 07/04/2007"); inp.datepicker("option", {dateFormat: "yy-mm-dd", defaultDate: "2007-04-02"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(2007, 4 - 1, 2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date 2007-04-02"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 2007-04-02"); // Date value date = new Date(2007, 1 - 1, 26); inp.datepicker("option", {dateFormat: "mm/dd/yy", defaultDate: date}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, "Default date 01/26/2007"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 01/26/2007"); }); test("miscellaneous", function() { expect( 19 ); var curYear, longNames, shortNames, date, dp = $("#ui-datepicker-div"), - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); // Year range function genRange(start, offset) { var i = start, @@ -417,7 +420,7 @@ test("miscellaneous", function() { test("minMax", function() { expect( 23 ); var date, - inp = TestHelpers.datepicker.init("#inp"), + inp = datepickerTestHelpers.init("#inp"), dp = $("#ui-datepicker-div"), lastYear = new Date(2007, 6 - 1, 4), nextYear = new Date(2009, 6 - 1, 4), @@ -426,45 +429,45 @@ test("minMax", function() { inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), lastYear, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), lastYear, "Min/max - null, null - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), nextYear, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), nextYear, "Min/max - null, null - ctrl+pgdn"); inp.datepicker("option", {minDate: minDate}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - 02/29/2008, null - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), nextYear, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), nextYear, "Min/max - 02/29/2008, null - ctrl+pgdn"); inp.datepicker("option", {maxDate: maxDate}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - 02/29/2008, 12/07/2008 - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - 02/29/2008, 12/07/2008 - ctrl+pgdn"); inp.datepicker("option", {minDate: null}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), lastYear, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), lastYear, "Min/max - null, 12/07/2008 - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - null, 12/07/2008 - ctrl+pgdn"); // Relative dates date = new Date(); @@ -473,31 +476,31 @@ test("minMax", function() { datepicker("hide").val("").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Min/max - -1w, +1 M +10 D - ctrl+pgup"); - date = TestHelpers.datepicker.addMonths(new Date(), 1); + date = datepickerTestHelpers.addMonths(new Date(), 1); date.setDate(date.getDate() + 10); inp.val("").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date, + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Min/max - -1w, +1 M +10 D - ctrl+pgdn"); // With existing date - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); inp.val("06/04/2008").datepicker("option", {minDate: minDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min"); inp.datepicker("option", {minDate: null}).val("01/04/2008").datepicker("option", {minDate: minDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); inp.datepicker("option", {minDate: null}).val("06/04/2008").datepicker("option", {maxDate: maxDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate < max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate < max"); inp.datepicker("option", {maxDate: null}).val("01/04/2009").datepicker("option", {maxDate: maxDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); inp.datepicker("option", {maxDate: null}).val("01/04/2008").datepicker("option", {minDate: minDate, maxDate: maxDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); inp.datepicker("option", {maxDate: null}).val("06/04/2008").datepicker("option", {minDate: minDate, maxDate: maxDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min, < max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min, < max"); inp.datepicker("option", {maxDate: null}).val("01/04/2009").datepicker("option", {minDate: minDate, maxDate: maxDate}); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); inp.datepicker("option", {yearRange: "-0:+1"}).val("01/01/" + new Date().getFullYear()); ok(dp.find(".ui-datepicker-prev").hasClass("ui-state-disabled"), "Year Range Test - previous button disabled at 1/1/minYear"); @@ -524,50 +527,50 @@ test("minMax", function() { test("setDate", function() { expect( 24 ); var inl, alt, minDate, maxDate, dateAndTimeToSet, dateAndTimeClone, - inp = TestHelpers.datepicker.init("#inp"), + inp = datepickerTestHelpers.init("#inp"), date1 = new Date(2008, 6 - 1, 4), date2 = new Date(); ok(inp.datepicker("getDate") == null, "Set date - default"); inp.datepicker("setDate", date1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - 2008-06-04"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - 2008-06-04"); date1 = new Date(); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", +7); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - +7"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - +7"); date2.setFullYear(date2.getFullYear() + 2); inp.datepicker("setDate", "+2y"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date2, "Set date - +2y"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date2, "Set date - +2y"); inp.datepicker("setDate", date1, date2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - two dates"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - two dates"); inp.datepicker("setDate"); ok(inp.datepicker("getDate") == null, "Set date - null"); // Relative to current date date1 = new Date(); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", "c +7"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - c +7"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c +7"); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", "c+7"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - c+7"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c+7"); date1.setDate(date1.getDate() - 21); inp.datepicker("setDate", "c -3 w"); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date - c -3 w"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c -3 w"); // Inline - inl = TestHelpers.datepicker.init("#inl"); + inl = datepickerTestHelpers.init("#inl"); date1 = new Date(2008, 6 - 1, 4); date2 = new Date(); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - default"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - default"); inl.datepicker("setDate", date1); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - 2008-06-04"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - 2008-06-04"); date1 = new Date(); date1.setDate(date1.getDate() + 7); inl.datepicker("setDate", +7); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - +7"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - +7"); date2.setFullYear(date2.getFullYear() + 2); inl.datepicker("setDate", "+2y"); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - +2y"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - +2y"); inl.datepicker("setDate", date1, date2); - TestHelpers.datepicker.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - two dates"); + datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - two dates"); inl.datepicker("setDate"); ok(inl.datepicker("getDate") == null, "Set date inline - null"); // Alternate field @@ -578,23 +581,23 @@ test("setDate", function() { equal(inp.val(), "06/04/2008", "Set date alternate - 06/04/2008"); equal(alt.val(), "2008-06-04", "Set date alternate - 2008-06-04"); // With minimum/maximum - inp = TestHelpers.datepicker.init("#inp"); + inp = datepickerTestHelpers.init("#inp"); date1 = new Date(2008, 1 - 1, 4); date2 = new Date(2008, 6 - 1, 4); minDate = new Date(2008, 2 - 1, 29); maxDate = new Date(2008, 3 - 1, 28); inp.val("").datepicker("option", {minDate: minDate}).datepicker("setDate", date2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date2, "Set date min/max - setDate > min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date2, "Set date min/max - setDate > min"); inp.datepicker("setDate", date1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); inp.val("").datepicker("option", {maxDate: maxDate, minDate: null}).datepicker("setDate", date1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), date1, "Set date min/max - setDate < max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date min/max - setDate < max"); inp.datepicker("setDate", date2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); inp.val("").datepicker("option", {minDate: minDate}).datepicker("setDate", date1); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); inp.datepicker("setDate", date2); - TestHelpers.datepicker.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); + datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); dateAndTimeToSet = new Date(2008, 3 - 1, 28, 1, 11, 0); dateAndTimeClone = new Date(2008, 3 - 1, 28, 1, 11, 0); inp.datepicker("setDate", dateAndTimeToSet); @@ -603,7 +606,7 @@ test("setDate", function() { test("altField", function() { expect( 10 ); - var inp = TestHelpers.datepicker.init("#inp"), + var inp = datepickerTestHelpers.init("#inp"), alt = $("#alt"); // No alternate field set alt.val(""); @@ -642,7 +645,7 @@ test("altField", function() { test("autoSize", function() { expect( 15 ); - var inp = TestHelpers.datepicker.init("#inp"); + var inp = datepickerTestHelpers.init("#inp"); equal(inp.prop("size"), 20, "Auto size - default"); inp.datepicker("option", "autoSize", true); equal(inp.prop("size"), 10, "Auto size - mm/dd/yy"); @@ -680,7 +683,7 @@ test("autoSize", function() { test("daylightSaving", function() { expect( 25 ); - var inp = TestHelpers.datepicker.init("#inp"), + var inp = datepickerTestHelpers.init("#inp"), dp = $("#ui-datepicker-div"); ok(true, "Daylight saving - " + new Date()); // Australia, Sydney - AM change, southern hemisphere @@ -786,7 +789,7 @@ test("callbacks", function() { expect( 13 ); // Before show var dp, day20, day21, - inp = TestHelpers.datepicker.init("#inp", {beforeShow: beforeAll}), + inp = datepickerTestHelpers.init("#inp", {beforeShow: beforeAll}), inst = $.data(inp[0], "datepicker"); equal($.datepicker._get(inst, "currentText"), "Today", "Before show - initial"); inp.val("02/04/2008").datepicker("show"); @@ -796,7 +799,7 @@ test("callbacks", function() { deepEqual(beforeShowInst, inst, "Before show - inst OK"); inp.datepicker("hide").datepicker("destroy"); // Before show day - inp = TestHelpers.datepicker.init("#inp", {beforeShowDay: beforeDay}); + inp = datepickerTestHelpers.init("#inp", {beforeShowDay: beforeDay}); dp = $("#ui-datepicker-div"); inp.val("02/04/2008").datepicker("show"); ok(beforeShowDayThis.id === inp[0].id, "Before show day - this OK"); @@ -815,7 +818,7 @@ test("callbacks", function() { test("beforeShowDay - tooltips with quotes", function() { expect( 1 ); var inp, dp; - inp = TestHelpers.datepicker.init("#inp", { + inp = datepickerTestHelpers.init("#inp", { beforeShowDay: function() { return [ true, "", "'" ]; } @@ -830,7 +833,7 @@ test("beforeShowDay - tooltips with quotes", function() { test("localisation", function() { expect( 24 ); var dp, month, day, date, - inp = TestHelpers.datepicker.init("#inp", $.datepicker.regional.fr); + inp = datepickerTestHelpers.init("#inp", $.datepicker.regional.fr); inp.datepicker("option", {dateFormat: "DD, d MM yy", showButtonPanel:true, changeMonth:true, changeYear:true}).val("").datepicker("show"); dp = $("#ui-datepicker-div"); equal($(".ui-datepicker-close", dp).text(), "Fermer", "Localisation - close"); @@ -897,72 +900,72 @@ test("iso8601Week", function() { test("parseDate", function() { expect( 26 ); - TestHelpers.datepicker.init("#inp"); + datepickerTestHelpers.init("#inp"); var currentYear, gmtDate, fr, settings, zh; ok($.datepicker.parseDate("d m y", "") == null, "Parse date empty"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("d m y", "3 2 01"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("d m y", "3 2 01"), new Date(2001, 2 - 1, 3), "Parse date d m y"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("dd mm yy", "03 02 2001"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("dd mm yy", "03 02 2001"), new Date(2001, 2 - 1, 3), "Parse date dd mm yy"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("d m y", "13 12 01"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("d m y", "13 12 01"), new Date(2001, 12 - 1, 13), "Parse date d m y"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("dd mm yy", "13 12 2001"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("dd mm yy", "13 12 2001"), new Date(2001, 12 - 1, 13), "Parse date dd mm yy"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-o", "01-34"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-o", "01-34"), new Date(2001, 2 - 1, 3), "Parse date y-o"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("yy-oo", "2001-347"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("yy-oo", "2001-347"), new Date(2001, 12 - 1, 13), "Parse date yy-oo"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("oo yy", "348 2004"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("oo yy", "348 2004"), new Date(2004, 12 - 1, 13), "Parse date oo yy"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("D d M y", "Sat 3 Feb 01"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("D d M y", "Sat 3 Feb 01"), new Date(2001, 2 - 1, 3), "Parse date D d M y"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("d MM DD yy", "3 February Saturday 2001"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("d MM DD yy", "3 February Saturday 2001"), new Date(2001, 2 - 1, 3), "Parse date dd MM DD yy"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Saturday, February 3, 2001"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Saturday, February 3, 2001"), new Date(2001, 2 - 1, 3), "Parse date DD, MM d, yy"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("'day' d 'of' MM (''DD''), yy", + datepickerTestHelpers.equalsDate($.datepicker.parseDate("'day' d 'of' MM (''DD''), yy", "day 3 of February ('Saturday'), 2001"), new Date(2001, 2 - 1, 3), "Parse date 'day' d 'of' MM (''DD''), yy"); currentYear = new Date().getFullYear(); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000) + "-02-03"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000) + "-02-03"), new Date(currentYear, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 10) + "-02-03"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 10) + "-02-03"), new Date(currentYear+10, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 11) + "-02-03"), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 11) + "-02-03"), new Date(currentYear-89, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", "80-02-03", {shortYearCutoff: 80}), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", "80-02-03", {shortYearCutoff: 80}), new Date(2080, 2 - 1, 3), "Parse date y-m-d - cutoff 80"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", "81-02-03", {shortYearCutoff: 80}), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", "81-02-03", {shortYearCutoff: 80}), new Date(1981, 2 - 1, 3), "Parse date y-m-d - cutoff 80"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 60) + "-02-03", {shortYearCutoff: "+60"}), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 60) + "-02-03", {shortYearCutoff: "+60"}), new Date(currentYear + 60, 2 - 1, 3), "Parse date y-m-d - cutoff +60"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 61) + "-02-03", {shortYearCutoff: "+60"}), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 61) + "-02-03", {shortYearCutoff: "+60"}), new Date(currentYear - 39, 2 - 1, 3), "Parse date y-m-d - cutoff +60"); gmtDate = new Date(2001, 2 - 1, 3); gmtDate.setMinutes(gmtDate.getMinutes() - gmtDate.getTimezoneOffset()); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("@", "981158400000"), gmtDate, "Parse date @"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("!", "631167552000000000"), gmtDate, "Parse date !"); + datepickerTestHelpers.equalsDate($.datepicker.parseDate("@", "981158400000"), gmtDate, "Parse date @"); + datepickerTestHelpers.equalsDate($.datepicker.parseDate("!", "631167552000000000"), gmtDate, "Parse date !"); fr = $.datepicker.regional.fr; settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames, monthNamesShort: fr.monthNamesShort, monthNames: fr.monthNames}; - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("D d M y", "Lun. 9 avr. 01", settings), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("D d M y", "Lun. 9 avr. 01", settings), new Date(2001, 4 - 1, 9), "Parse date D M y with settings"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("d MM DD yy", "9 Avril Lundi 2001", settings), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("d MM DD yy", "9 Avril Lundi 2001", settings), new Date(2001, 4 - 1, 9), "Parse date d MM DD yy with settings"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Lundi, Avril 9, 2001", settings), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Lundi, Avril 9, 2001", settings), new Date(2001, 4 - 1, 9), "Parse date DD, MM d, yy with settings"); - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("'jour' d 'de' MM (''DD''), yy", "jour 9 de Avril ('Lundi'), 2001", settings), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("'jour' d 'de' MM (''DD''), yy", "jour 9 de Avril ('Lundi'), 2001", settings), new Date(2001, 4 - 1, 9), "Parse date 'jour' d 'de' MM (''DD''), yy with settings"); zh = $.datepicker.regional["zh-CN"]; - TestHelpers.datepicker.equalsDate($.datepicker.parseDate("yy M d", "2011 十一月 22", zh), + datepickerTestHelpers.equalsDate($.datepicker.parseDate("yy M d", "2011 十一月 22", zh), new Date(2011, 11 - 1, 22), "Parse date yy M d with zh-CN"); }); test("parseDateErrors", function() { expect( 18 ); - TestHelpers.datepicker.init("#inp"); + datepickerTestHelpers.init("#inp"); var fr, settings; function expectError(expr, value, error) { try { @@ -1037,7 +1040,7 @@ test("Ticket #7244: date parser does not fail when too many numbers are passed i test("formatDate", function() { expect( 16 ); - TestHelpers.datepicker.init("#inp"); + datepickerTestHelpers.init("#inp"); var gmtDate, fr, settings; equal($.datepicker.formatDate("d m y", new Date(2001, 2 - 1, 3)), "3 2 01", "Format date d m y"); @@ -1090,7 +1093,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler var inp, dp; - inp = TestHelpers.datepicker.init( "#inp", { + inp = datepickerTestHelpers.init( "#inp", { beforeShow: function() { } }); @@ -1099,7 +1102,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler equal( dp.css( "display" ), "block", "beforeShow returns nothing" ); inp.datepicker( "hide" ).datepicker( "destroy" ); - inp = TestHelpers.datepicker.init( "#inp", { + inp = datepickerTestHelpers.init( "#inp", { beforeShow: function() { return true; } @@ -1110,7 +1113,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler inp.datepicker( "hide" ); inp.datepicker( "destroy" ); - inp = TestHelpers.datepicker.init( "#inp", { + inp = datepickerTestHelpers.init( "#inp", { beforeShow: function() { return false; } @@ -1121,4 +1124,4 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler inp.datepicker( "destroy" ); }); -})(jQuery); +} ); diff --git a/tests/unit/datepicker/datepicker_test_helpers.js b/tests/unit/datepicker/datepicker_test_helpers.js index 82610393bec..40dc934105a 100644 --- a/tests/unit/datepicker/datepicker_test_helpers.js +++ b/tests/unit/datepicker/datepicker_test_helpers.js @@ -1,4 +1,9 @@ -TestHelpers.datepicker = { +define( [ + "lib/helper", + "ui/datepicker" +], function( testHelpers ) { + +var datepickerTestHelpers = { addMonths: function(date, offset) { var maxDay = 32 - new Date(date.getFullYear(), date.getMonth() + offset, 32).getDate(); date.setDate(Math.min(date.getDate(), maxDay)); @@ -20,8 +25,12 @@ TestHelpers.datepicker = { }, initNewInput: function( options ) { var id = $( "" ).appendTo( "#qunit-fixture" ); - return TestHelpers.datepicker.init( id, options ); + return datepickerTestHelpers.init( id, options ); }, - onFocus: TestHelpers.onFocus, + onFocus: testHelpers.onFocus, PROP_NAME: "datepicker" }; + +return datepickerTestHelpers; + +} ); From 652ee4cfa98ae3d2cf6a7e3325013da3bba78846 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:22:54 -0400 Subject: [PATCH 21/29] Tests: Support `$.uiBackCompat = false` via `data-no-back-compat` --- tests/lib/bootstrap.js | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/tests/lib/bootstrap.js b/tests/lib/bootstrap.js index 94954ba3962..b9598c6dfc4 100644 --- a/tests/lib/bootstrap.js +++ b/tests/lib/bootstrap.js @@ -41,10 +41,10 @@ function requireModules( dependencies, callback, modules ) { } // Load a set of test file along with the required test infrastructure -function requireTests( dependencies, callback ) { +function requireTests( dependencies, noBackCompat ) { dependencies = [ "../../lib/qunit", - "jquery", + noBackCompat ? "jquery-no-back-compat" : "jquery", "jquery-simulate", "qunit-assert-classes", "../../lib/qunit-assert-domequal" @@ -101,6 +101,7 @@ function swarmInject() { // - data-widget: A widget to load test modules for // - Automatically loads common, core, events, methods, and options // - data-deprecated: Loads the deprecated test modules for a widget +// - data-no-back-compat: Set $.uiBackCompat to false (function() { // Find the script element @@ -117,7 +118,9 @@ function swarmInject() { modules = []; } var widget = script.getAttribute( "data-widget" ); - var deprecated = script.getAttribute( "data-deprecated" ); + var deprecated = !!script.getAttribute( "data-deprecated" ); + var noBackCompat = !!script.getAttribute( "data-no-back-compat" ); + if ( widget ) { modules = modules.concat([ widget + ( deprecated ? "_common_deprecated" : "_common" ), @@ -136,12 +139,19 @@ function swarmInject() { script.src = "../../../external/requirejs/require.js"; script.onload = function() { + // Create a module that disables back compat for UI modules + define( "jquery-no-back-compat", [ "jquery" ], function( $ ) { + $.uiBackCompat = false; + + return $; + } ); + // Create a dummy bridge if we're not actually testing in PhantomJS if ( !/PhantomJS/.test( navigator.userAgent ) ) { define( "phantom-bridge", function() {} ); } - requireTests( modules ); + requireTests( modules, noBackCompat ); }; document.documentElement.appendChild( script ); } )(); From 42c93e27b3d73867b3fb6d49ee7053d3805930c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:23:50 -0400 Subject: [PATCH 22/29] Dialog: Convert tests to new infrastructure --- tests/unit/dialog/dialog.html | 38 +----------- tests/unit/dialog/dialog_common.js | 9 ++- tests/unit/dialog/dialog_common_deprecated.js | 9 ++- tests/unit/dialog/dialog_core.js | 11 ++-- tests/unit/dialog/dialog_deprecated.html | 37 +---------- tests/unit/dialog/dialog_deprecated.js | 7 ++- tests/unit/dialog/dialog_events.js | 23 +++---- tests/unit/dialog/dialog_methods.js | 18 +++--- tests/unit/dialog/dialog_options.js | 61 ++++++++++--------- tests/unit/dialog/dialog_test_helpers.js | 12 +++- 10 files changed, 92 insertions(+), 133 deletions(-) diff --git a/tests/unit/dialog/dialog.html b/tests/unit/dialog/dialog.html index 5434e6bfc3b..aa0e3d3ec1c 100644 --- a/tests/unit/dialog/dialog.html +++ b/tests/unit/dialog/dialog.html @@ -4,42 +4,8 @@ jQuery UI Dialog Test Suite - - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/dialog/dialog_common.js b/tests/unit/dialog/dialog_common.js index fc5105d7437..389b2ddff78 100644 --- a/tests/unit/dialog/dialog_common.js +++ b/tests/unit/dialog/dialog_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "dialog", { +define( [ + "lib/common", + "ui/dialog" +], function( common ) { + +common.testWidget( "dialog", { defaults: { appendTo: "body", autoOpen: true, @@ -44,3 +49,5 @@ TestHelpers.commonWidgetTests( "dialog", { resizeStop: null } }); + +} ); diff --git a/tests/unit/dialog/dialog_common_deprecated.js b/tests/unit/dialog/dialog_common_deprecated.js index 30658696e0b..7b00912779b 100644 --- a/tests/unit/dialog/dialog_common_deprecated.js +++ b/tests/unit/dialog/dialog_common_deprecated.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "dialog", { +define( [ + "lib/common", + "ui/dialog" +], function( common ) { + +common.testWidget( "dialog", { defaults: { appendTo: "body", autoOpen: true, @@ -45,3 +50,5 @@ TestHelpers.commonWidgetTests( "dialog", { resizeStop: null } }); + +} ); diff --git a/tests/unit/dialog/dialog_core.js b/tests/unit/dialog/dialog_core.js index 73d24fed0af..cb086ce8def 100644 --- a/tests/unit/dialog/dialog_core.js +++ b/tests/unit/dialog/dialog_core.js @@ -1,8 +1,7 @@ -/* - * dialog_core.js - */ - -(function($) { +define( [ + "jquery", + "ui/dialog" +], function( $ ) { // TODO add teardown callback to remove dialogs module("dialog: core"); @@ -306,4 +305,4 @@ asyncTest( "interaction between overlay and other dialogs", function() { }); }); -})(jQuery); +} ); diff --git a/tests/unit/dialog/dialog_deprecated.html b/tests/unit/dialog/dialog_deprecated.html index 5bcdf75e57b..2d20b62914c 100644 --- a/tests/unit/dialog/dialog_deprecated.html +++ b/tests/unit/dialog/dialog_deprecated.html @@ -4,41 +4,8 @@ jQuery UI Dialog Test Suite - - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/dialog/dialog_deprecated.js b/tests/unit/dialog/dialog_deprecated.js index 55c18045739..1f7087c57ee 100644 --- a/tests/unit/dialog/dialog_deprecated.js +++ b/tests/unit/dialog/dialog_deprecated.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/dialog" +], function( $ ) { module( "dialog (deprecated): options" ); @@ -24,4 +27,4 @@ test( "dialogClass", function( assert ) { element.remove(); }); -})( jQuery ); +} ); diff --git a/tests/unit/dialog/dialog_events.js b/tests/unit/dialog/dialog_events.js index f4b353b8dd4..a6e4c0501b4 100644 --- a/tests/unit/dialog/dialog_events.js +++ b/tests/unit/dialog/dialog_events.js @@ -1,7 +1,8 @@ -/* - * dialog_events.js - */ -(function($) { +define( [ + "jquery", + "./dialog_test_helpers", + "ui/dialog" +], function( $, dialogTestHelpers ) { module("dialog: events"); @@ -103,7 +104,7 @@ test("dragStart", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -131,7 +132,7 @@ test("drag", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -155,7 +156,7 @@ test("dragStop", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -183,7 +184,7 @@ test("resizeStart", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -215,7 +216,7 @@ test("resize", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -243,7 +244,7 @@ test("resizeStop", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); element.remove(); }); @@ -366,4 +367,4 @@ test("ensure dialog keeps focus when clicking modal overlay", function() { element.remove(); }); -})(jQuery); +} ); diff --git a/tests/unit/dialog/dialog_methods.js b/tests/unit/dialog/dialog_methods.js index c92f1f1b4a7..10b0fd7bb95 100644 --- a/tests/unit/dialog/dialog_methods.js +++ b/tests/unit/dialog/dialog_methods.js @@ -1,7 +1,7 @@ -/* - * dialog_methods.js - */ -(function($) { +define( [ + "jquery", + "ui/dialog" +], function( $ ) { module("dialog: methods", { teardown: function() { @@ -33,18 +33,18 @@ test("init", function() { ok(true, "arbitrary option setter after init"); }); -test("destroy", function() { +test("destroy", function( assert ) { expect( 17 ); var element, element2; $( "#dialog1, #form-dialog" ).hide(); - domEqual( "#dialog1", function() { + assert.domEqual( "#dialog1", function() { var dialog = $( "#dialog1" ).dialog().dialog( "destroy" ); equal( dialog.parent()[ 0 ], $( "#qunit-fixture" )[ 0 ] ); equal( dialog.index(), 0 ); }); - domEqual( "#form-dialog", function() { + assert.domEqual( "#form-dialog", function() { var dialog = $( "#form-dialog" ).dialog().dialog( "destroy" ); equal( dialog.parent()[ 0 ], $( "#qunit-fixture" )[ 0 ] ); equal( dialog.index(), 2 ); @@ -56,7 +56,7 @@ test("destroy", function() { minHeight: "100px", height: "200px" }); - domEqual( "#dialog1", function() { + assert.domEqual( "#dialog1", function() { $( "#dialog1" ).dialog().dialog( "destroy" ); }); @@ -264,4 +264,4 @@ test("#5531: dialog width should be at least minWidth on creation", function () }); -})(jQuery); +} ); diff --git a/tests/unit/dialog/dialog_options.js b/tests/unit/dialog/dialog_options.js index 1c3648f111d..e4ff6ac7202 100644 --- a/tests/unit/dialog/dialog_options.js +++ b/tests/unit/dialog/dialog_options.js @@ -1,7 +1,10 @@ -/* - * dialog_options.js - */ -(function($) { +define( [ + "jquery", + "./dialog_test_helpers", + "ui/dialog", + "ui/effect-blind", + "ui/effect-explode" +], function( $, dialogTestHelpers ) { module("dialog: options"); @@ -228,15 +231,15 @@ test("draggable", function() { var element = $("
").dialog({ draggable: false }); - TestHelpers.dialog.testDrag(element, 50, -50, 0, 0); + dialogTestHelpers.testDrag(element, 50, -50, 0, 0); element.dialog("option", "draggable", true); - TestHelpers.dialog.testDrag(element, 50, -50, 50, -50); + dialogTestHelpers.testDrag(element, 50, -50, 50, -50); element.remove(); element = $("
").dialog({ draggable: true }); - TestHelpers.dialog.testDrag(element, 50, -50, 50, -50); + dialogTestHelpers.testDrag(element, 50, -50, 50, -50); element.dialog("option", "draggable", false); - TestHelpers.dialog.testDrag(element, 50, -50, 0, 0); + dialogTestHelpers.testDrag(element, 50, -50, 0, 0); element.remove(); }); @@ -266,17 +269,17 @@ test("maxHeight", function( assert ) { expect(3); var element = $("
").dialog({ maxHeight: 200 }); - TestHelpers.dialog.drag(element, ".ui-resizable-s", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-s", 1000, 1000); assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }); - TestHelpers.dialog.drag(element, ".ui-resizable-n", -1000, -1000); + dialogTestHelpers.drag(element, ".ui-resizable-n", -1000, -1000); assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }).dialog("option", "maxHeight", 300); - TestHelpers.dialog.drag(element, ".ui-resizable-s", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-s", 1000, 1000); assert.close(element.dialog("widget").height(), 300, 1, "maxHeight"); element.remove(); }); @@ -285,17 +288,17 @@ test("maxWidth", function( assert ) { expect(3); var element = $("
").dialog({ maxWidth: 200 }); - TestHelpers.dialog.drag(element, ".ui-resizable-e", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-e", 1000, 1000); assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }); - TestHelpers.dialog.drag(element, ".ui-resizable-w", -1000, -1000); + dialogTestHelpers.drag(element, ".ui-resizable-w", -1000, -1000); assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }).dialog("option", "maxWidth", 300); - TestHelpers.dialog.drag(element, ".ui-resizable-w", -1000, -1000); + dialogTestHelpers.drag(element, ".ui-resizable-w", -1000, -1000); assert.close(element.dialog("widget").width(), 300, 1, "maxWidth"); element.remove(); }); @@ -304,17 +307,17 @@ test("minHeight", function( assert ) { expect(3); var element = $("
").dialog({ minHeight: 10 }); - TestHelpers.dialog.drag(element, ".ui-resizable-s", -1000, -1000); + dialogTestHelpers.drag(element, ".ui-resizable-s", -1000, -1000); assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }); - TestHelpers.dialog.drag(element, ".ui-resizable-n", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-n", 1000, 1000); assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }).dialog("option", "minHeight", 30); - TestHelpers.dialog.drag(element, ".ui-resizable-n", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-n", 1000, 1000); assert.close(element.dialog("widget").height(), 30, 1, "minHeight"); element.remove(); }); @@ -323,17 +326,17 @@ test("minWidth", function( assert ) { expect(3); var element = $("
").dialog({ minWidth: 10 }); - TestHelpers.dialog.drag(element, ".ui-resizable-e", -1000, -1000); + dialogTestHelpers.drag(element, ".ui-resizable-e", -1000, -1000); assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 10 }); - TestHelpers.dialog.drag(element, ".ui-resizable-w", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-w", 1000, 1000); assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 30 }).dialog("option", "minWidth", 30); - TestHelpers.dialog.drag(element, ".ui-resizable-w", 1000, 1000); + dialogTestHelpers.drag(element, ".ui-resizable-w", 1000, 1000); assert.close(element.dialog("widget").width(), 30, 1, "minWidth"); element.remove(); }); @@ -421,15 +424,15 @@ test("resizable", function() { expect(4); var element = $("
").dialog(); - TestHelpers.dialog.shouldResize(element, 50, 50, "[default]"); + dialogTestHelpers.shouldResize(element, 50, 50, "[default]"); element.dialog("option", "resizable", false); - TestHelpers.dialog.shouldResize(element, 0, 0, "disabled after init"); + dialogTestHelpers.shouldResize(element, 0, 0, "disabled after init"); element.remove(); element = $("
").dialog({ resizable: false }); - TestHelpers.dialog.shouldResize(element, 0, 0, "disabled in init options"); + dialogTestHelpers.shouldResize(element, 0, 0, "disabled in init options"); element.dialog("option", "resizable", true); - TestHelpers.dialog.shouldResize(element, 50, 50, "enabled after init"); + dialogTestHelpers.shouldResize(element, 50, 50, "enabled after init"); element.remove(); }); @@ -494,18 +497,18 @@ test("#4826: setting resizable false toggles resizable on dialog", function() { var i, element = $("
").dialog({ resizable: false }); - TestHelpers.dialog.shouldResize(element, 0, 0, "[default]"); + dialogTestHelpers.shouldResize(element, 0, 0, "[default]"); for (i=0; i<2; i++) { element.dialog("close").dialog("open"); - TestHelpers.dialog.shouldResize(element, 0, 0, "initialized with resizable false toggle ("+ (i+1) +")"); + dialogTestHelpers.shouldResize(element, 0, 0, "initialized with resizable false toggle ("+ (i+1) +")"); } element.remove(); element = $("
").dialog({ resizable: true }); - TestHelpers.dialog.shouldResize(element, 50, 50, "[default]"); + dialogTestHelpers.shouldResize(element, 50, 50, "[default]"); for (i=0; i<2; i++) { element.dialog("close").dialog("option", "resizable", false).dialog("open"); - TestHelpers.dialog.shouldResize(element, 0, 0, "set option resizable false toggle ("+ (i+1) +")"); + dialogTestHelpers.shouldResize(element, 0, 0, "set option resizable false toggle ("+ (i+1) +")"); } element.remove(); @@ -551,4 +554,4 @@ asyncTest( "Open followed by close during show effect", function() { }, 100 ); }); -})(jQuery); +} ); diff --git a/tests/unit/dialog/dialog_test_helpers.js b/tests/unit/dialog/dialog_test_helpers.js index 705eb3010be..f11c77cded4 100644 --- a/tests/unit/dialog/dialog_test_helpers.js +++ b/tests/unit/dialog/dialog_test_helpers.js @@ -1,4 +1,6 @@ -TestHelpers.dialog = { +define( function() { + +var dialogTestHelpers = { drag: function(element, handle, dx, dy) { var d = element.dialog("widget"); //this mouseover is to work around a limitation in resizable @@ -14,7 +16,7 @@ TestHelpers.dialog = { handle = $(".ui-dialog-titlebar", d), offsetBefore = d.offset(); - TestHelpers.dialog.drag(element, handle, dx, dy); + dialogTestHelpers.drag(element, handle, dx, dy); offsetAfter = d.offset(); @@ -34,7 +36,7 @@ TestHelpers.dialog = { heightBefore = element.height(), widthBefore = element.width(); - TestHelpers.dialog.drag(element, handle, 50, 50); + dialogTestHelpers.drag(element, handle, 50, 50); heightAfter = element.height(); widthAfter = element.width(); @@ -45,3 +47,7 @@ TestHelpers.dialog = { deepEqual(actual, expected, "resized[" + 50 + ", " + 50 + "] " + msg); } }; + +return dialogTestHelpers; + +} ); From 55c8af71714b2ea35c548ddfaa03a5cfef6f5a5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:28:55 -0400 Subject: [PATCH 23/29] Tooltip: Convert tests to new infrastructure --- tests/unit/tooltip/tooltip.html | 30 ++----------------- tests/unit/tooltip/tooltip_common.js | 9 +++++- .../unit/tooltip/tooltip_common_deprecated.js | 9 +++++- tests/unit/tooltip/tooltip_core.js | 7 +++-- tests/unit/tooltip/tooltip_deprecated.html | 28 ++--------------- tests/unit/tooltip/tooltip_deprecated.js | 7 +++-- tests/unit/tooltip/tooltip_events.js | 7 +++-- tests/unit/tooltip/tooltip_methods.js | 13 ++++---- tests/unit/tooltip/tooltip_options.js | 7 +++-- 9 files changed, 48 insertions(+), 69 deletions(-) diff --git a/tests/unit/tooltip/tooltip.html b/tests/unit/tooltip/tooltip.html index 1a7b94ae22c..1f0adc9f462 100644 --- a/tests/unit/tooltip/tooltip.html +++ b/tests/unit/tooltip/tooltip.html @@ -4,34 +4,8 @@ jQuery UI Tooltip Test Suite - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/tooltip/tooltip_common.js b/tests/unit/tooltip/tooltip_common.js index 87e73f7ea6c..f8045fc3340 100644 --- a/tests/unit/tooltip/tooltip_common.js +++ b/tests/unit/tooltip/tooltip_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "tooltip", { +define( [ + "lib/common", + "ui/tooltip" +], function( common ) { + +common.testWidget( "tooltip", { defaults: { classes: { "ui-tooltip": "ui-corner-all ui-widget-shadow" @@ -21,3 +26,5 @@ TestHelpers.commonWidgetTests( "tooltip", { open: null } }); + +} ); diff --git a/tests/unit/tooltip/tooltip_common_deprecated.js b/tests/unit/tooltip/tooltip_common_deprecated.js index 6ea0e65ffbb..d32e7656d3d 100644 --- a/tests/unit/tooltip/tooltip_common_deprecated.js +++ b/tests/unit/tooltip/tooltip_common_deprecated.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "tooltip", { +define( [ + "lib/common", + "ui/tooltip" +], function( common ) { + +common.testWidget( "tooltip", { defaults: { classes: { "ui-tooltip": "ui-corner-all ui-widget-shadow" @@ -22,3 +27,5 @@ TestHelpers.commonWidgetTests( "tooltip", { open: null } }); + +} ); diff --git a/tests/unit/tooltip/tooltip_core.js b/tests/unit/tooltip/tooltip_core.js index d4520a4ea68..fa24d72ce71 100644 --- a/tests/unit/tooltip/tooltip_core.js +++ b/tests/unit/tooltip/tooltip_core.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/tooltip" +], function( $ ) { module( "tooltip: core" ); @@ -218,4 +221,4 @@ asyncTest( "multiple active delegated tooltips", function() { step1(); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tooltip/tooltip_deprecated.html b/tests/unit/tooltip/tooltip_deprecated.html index 813768337fb..d21fea57b33 100644 --- a/tests/unit/tooltip/tooltip_deprecated.html +++ b/tests/unit/tooltip/tooltip_deprecated.html @@ -4,32 +4,8 @@ jQuery UI Tooltip Test Suite - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/tooltip/tooltip_deprecated.js b/tests/unit/tooltip/tooltip_deprecated.js index a53a2705091..057171ee262 100644 --- a/tests/unit/tooltip/tooltip_deprecated.js +++ b/tests/unit/tooltip/tooltip_deprecated.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/tooltip" +], function( $ ) { module( "tooltip: (deprecated) options" ); @@ -10,4 +13,4 @@ test( "tooltipClass", function( assert ) { assert.hasClasses( $( "#" + element.data( "ui-tooltip-id" ) ), "custom" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tooltip/tooltip_events.js b/tests/unit/tooltip/tooltip_events.js index de16471aedf..a953c6e9140 100644 --- a/tests/unit/tooltip/tooltip_events.js +++ b/tests/unit/tooltip/tooltip_events.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/tooltip" +], function( $ ) { module( "tooltip: events" ); @@ -54,4 +57,4 @@ test( "focus events", function() { element.trigger( "focusout" ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tooltip/tooltip_methods.js b/tests/unit/tooltip/tooltip_methods.js index f027d522620..3db7b8f7c06 100644 --- a/tests/unit/tooltip/tooltip_methods.js +++ b/tests/unit/tooltip/tooltip_methods.js @@ -1,17 +1,20 @@ -(function( $ ) { +define( [ + "jquery", + "ui/tooltip" +], function( $ ) { module( "tooltip: methods" ); -test( "destroy", function() { +test( "destroy", function( assert ) { expect( 3 ); var element = $( "#tooltipped1" ); - domEqual( "#tooltipped1", function() { + assert.domEqual( "#tooltipped1", function() { element.tooltip().tooltip( "destroy" ); }); // make sure that open tooltips are removed on destroy - domEqual( "#tooltipped1", function() { + assert.domEqual( "#tooltipped1", function() { element .tooltip() .tooltip( "open", $.Event( "mouseover", { target: element[0] }) ) @@ -133,4 +136,4 @@ test( "preserve changes to title attributes on close and destroy", function() { } ); }); -}( jQuery ) ); +} ); diff --git a/tests/unit/tooltip/tooltip_options.js b/tests/unit/tooltip/tooltip_options.js index 1d9d6b3f09d..d091e3bad4d 100644 --- a/tests/unit/tooltip/tooltip_options.js +++ b/tests/unit/tooltip/tooltip_options.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/tooltip" +], function( $ ) { module( "tooltip: options" ); @@ -209,4 +212,4 @@ test( "track and programmatic focus", function() { equal( "inputtitle", $( ".ui-tooltip" ).text() ); }); -}( jQuery ) ); +} ); From 129d5651c9dd37a122fa02ec2e70b91301587dd1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:35:27 -0400 Subject: [PATCH 24/29] Droppable: Convert tests to new infrastructure --- tests/unit/droppable/droppable.html | 33 ++----------------- tests/unit/droppable/droppable_common.js | 9 ++++- .../droppable/droppable_common_deprecated.js | 9 ++++- tests/unit/droppable/droppable_core.js | 14 ++++---- .../unit/droppable/droppable_deprecated.html | 29 ++-------------- tests/unit/droppable/droppable_deprecated.js | 1 + tests/unit/droppable/droppable_events.js | 7 ++-- tests/unit/droppable/droppable_methods.js | 27 +++++++-------- tests/unit/droppable/droppable_options.js | 11 ++++--- .../unit/droppable/droppable_test_helpers.js | 6 +++- 10 files changed, 59 insertions(+), 87 deletions(-) create mode 100644 tests/unit/droppable/droppable_deprecated.js diff --git a/tests/unit/droppable/droppable.html b/tests/unit/droppable/droppable.html index 4fc712a009a..9021f8c7806 100644 --- a/tests/unit/droppable/droppable.html +++ b/tests/unit/droppable/droppable.html @@ -4,36 +4,9 @@ jQuery UI Droppable Test Suite - - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/droppable/droppable_common.js b/tests/unit/droppable/droppable_common.js index 87d3ca1dba5..ef8e116922c 100644 --- a/tests/unit/droppable/droppable_common.js +++ b/tests/unit/droppable/droppable_common.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "droppable", { +define( [ + "lib/common", + "ui/droppable" +], function( common ) { + +common.testWidget( "droppable", { defaults: { accept: "*", addClasses: true, @@ -17,3 +22,5 @@ TestHelpers.commonWidgetTests( "droppable", { over: null } }); + +} ); diff --git a/tests/unit/droppable/droppable_common_deprecated.js b/tests/unit/droppable/droppable_common_deprecated.js index bd56aa35f9b..9d2f6c6b66c 100644 --- a/tests/unit/droppable/droppable_common_deprecated.js +++ b/tests/unit/droppable/droppable_common_deprecated.js @@ -1,4 +1,9 @@ -TestHelpers.commonWidgetTests( "droppable", { +define( [ + "lib/common", + "ui/droppable" +], function( common ) { + +common.testWidget( "droppable", { defaults: { accept: "*", activeClass: false, @@ -19,3 +24,5 @@ TestHelpers.commonWidgetTests( "droppable", { over: null } }); + +} ); diff --git a/tests/unit/droppable/droppable_core.js b/tests/unit/droppable/droppable_core.js index 53b08fd8565..9ea789544e0 100644 --- a/tests/unit/droppable/droppable_core.js +++ b/tests/unit/droppable/droppable_core.js @@ -1,8 +1,8 @@ -/* - * droppable_core.js - */ - -(function($) { +define( [ + "jquery", + "./droppable_test_helpers", + "ui/droppable" +], function( $, droppableTestHelpers ) { module("droppable: core"); @@ -20,10 +20,10 @@ test("element types", function() { (typeName === "table" && el.append("content")); el.droppable(); - TestHelpers.droppable.shouldDrop(); + droppableTestHelpers.shouldDrop(); el.droppable("destroy"); el.remove(); }); }); -})(jQuery); +} ); diff --git a/tests/unit/droppable/droppable_deprecated.html b/tests/unit/droppable/droppable_deprecated.html index 5af53a2f7b5..e47b41c6bf6 100644 --- a/tests/unit/droppable/droppable_deprecated.html +++ b/tests/unit/droppable/droppable_deprecated.html @@ -4,33 +4,8 @@ jQuery UI Droppable Test Suite - - - - - - - - - - - - - - - - + + diff --git a/tests/unit/droppable/droppable_deprecated.js b/tests/unit/droppable/droppable_deprecated.js new file mode 100644 index 00000000000..3931f5f06c8 --- /dev/null +++ b/tests/unit/droppable/droppable_deprecated.js @@ -0,0 +1 @@ +define( function() {} ); diff --git a/tests/unit/droppable/droppable_events.js b/tests/unit/droppable/droppable_events.js index 1b205bc9736..a60d9292ee3 100644 --- a/tests/unit/droppable/droppable_events.js +++ b/tests/unit/droppable/droppable_events.js @@ -1,4 +1,7 @@ -(function( $ ) { +define( [ + "jquery", + "ui/droppable" +], function( $ ) { module( "droppable: events" ); @@ -58,4 +61,4 @@ test("drop", function() { }); */ -})( jQuery ); +} ); diff --git a/tests/unit/droppable/droppable_methods.js b/tests/unit/droppable/droppable_methods.js index aebaf490c71..70a60d2cbc2 100644 --- a/tests/unit/droppable/droppable_methods.js +++ b/tests/unit/droppable/droppable_methods.js @@ -1,7 +1,8 @@ -/* - * droppable_methods.js - */ -(function($) { +define( [ + "jquery", + "./droppable_test_helpers", + "ui/droppable" +], function( $, droppableTestHelpers ) { module("droppable: methods"); @@ -47,16 +48,16 @@ test("enable", function() { var el, expected, actual; el = $("#droppable1").droppable({ disabled: true }); - TestHelpers.droppable.shouldNotDrop(); + droppableTestHelpers.shouldNotDrop(); el.droppable("enable"); - TestHelpers.droppable.shouldDrop(); + droppableTestHelpers.shouldDrop(); equal(el.droppable("option", "disabled"), false, "disabled option getter"); el.droppable("destroy"); el.droppable({ disabled: true }); - TestHelpers.droppable.shouldNotDrop(); + droppableTestHelpers.shouldNotDrop(); el.droppable("option", "disabled", false); equal(el.droppable("option", "disabled"), false, "disabled option setter"); - TestHelpers.droppable.shouldDrop(); + droppableTestHelpers.shouldDrop(); expected = $("
").droppable(), actual = expected.droppable("enable"); @@ -69,23 +70,23 @@ test( "disable", function( assert ) { var actual, expected, element = $( "#droppable1" ).droppable({ disabled: false }); - TestHelpers.droppable.shouldDrop(); + droppableTestHelpers.shouldDrop(); element.droppable( "disable" ); - TestHelpers.droppable.shouldNotDrop(); + droppableTestHelpers.shouldNotDrop(); equal( element.droppable( "option", "disabled" ), true, "disabled option getter" ); element.droppable( "destroy" ); element.droppable({ disabled: false }); - TestHelpers.droppable.shouldDrop(); + droppableTestHelpers.shouldDrop(); element.droppable( "option", "disabled", true ); assert.lacksClasses( element.droppable( "widget" ), "ui-state-disabled" ); ok( !element.droppable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); assert.hasClasses( element.droppable( "widget" ), "ui-droppable-disabled" ); equal( element.droppable( "option", "disabled" ), true, "disabled option setter" ); - TestHelpers.droppable.shouldNotDrop(); + droppableTestHelpers.shouldNotDrop(); expected = $( "
" ).droppable(); actual = expected.droppable( "disable" ); equal( actual, expected, "disable is chainable" ); }); -})( jQuery ); +} ); diff --git a/tests/unit/droppable/droppable_options.js b/tests/unit/droppable/droppable_options.js index 9a4be076d17..24a1a788eae 100644 --- a/tests/unit/droppable/droppable_options.js +++ b/tests/unit/droppable/droppable_options.js @@ -1,7 +1,8 @@ -/* - * droppable_options.js - */ -(function($) { +define( [ + "jquery", + "./droppable_test_helpers", + "ui/droppable" +], function( $ ) { module( "droppable: options" ); @@ -202,4 +203,4 @@ test( "tolerance, touch", function() { ok(false, 'missing test - untested code is broken code'); }); */ -})(jQuery); +} ); diff --git a/tests/unit/droppable/droppable_test_helpers.js b/tests/unit/droppable/droppable_test_helpers.js index ce972be6346..5ffb32f4c61 100644 --- a/tests/unit/droppable/droppable_test_helpers.js +++ b/tests/unit/droppable/droppable_test_helpers.js @@ -1,4 +1,6 @@ -TestHelpers.droppable = { +define( function() { + +return { shouldDrop: function() { // todo: actually implement this ok(true, "missing test - untested code is broken code"); @@ -8,3 +10,5 @@ TestHelpers.droppable = { ok(true, "missing test - untested code is broken code"); } }; + +} ); From 3ec2b22e793407daf4f5a01de6778a9c8fab15cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Mon, 6 Apr 2015 20:41:24 -0400 Subject: [PATCH 25/29] Tests: Remove old test infrastructure --- tests/.jshintrc | 2 - tests/jquery.js | 24 --- tests/unit/swarminject.js | 10 -- tests/unit/testsuite.js | 346 -------------------------------------- 4 files changed, 382 deletions(-) delete mode 100644 tests/jquery.js delete mode 100644 tests/unit/swarminject.js delete mode 100644 tests/unit/testsuite.js diff --git a/tests/.jshintrc b/tests/.jshintrc index d4665d6b66d..25c688b792f 100644 --- a/tests/.jshintrc +++ b/tests/.jshintrc @@ -22,7 +22,6 @@ "asyncTest": false, "deepEqual": false, "define": false, - "domEqual": false, "equal": false, "expect": false, "Globalize": false, @@ -36,7 +35,6 @@ "strictEqual": false, "stop": false, "test": false, - "TestHelpers": true, "JSHINT": false } } diff --git a/tests/jquery.js b/tests/jquery.js deleted file mode 100644 index 43ba2750a31..00000000000 --- a/tests/jquery.js +++ /dev/null @@ -1,24 +0,0 @@ -(function() { - -var current, version, url, - parts = document.location.search.slice( 1 ).split( "&" ), - length = parts.length, - i = 0; - -for ( ; i < length; i++ ) { - current = parts[ i ].split( "=" ); - if ( current[ 0 ] === "jquery" ) { - version = current[ 1 ]; - break; - } -} - -if ( version === "git" || version === "git1" ) { - url = "http://code.jquery.com/jquery-" + version + ".js"; -} else { - url = "../../../external/jquery-" + ( version || "1.11.2" ) + "/jquery.js"; -} - -document.write( "" ); - -}() ); diff --git a/tests/unit/swarminject.js b/tests/unit/swarminject.js deleted file mode 100644 index ebd3ccfac55..00000000000 --- a/tests/unit/swarminject.js +++ /dev/null @@ -1,10 +0,0 @@ -// load testswarm agent -(function() { - var url = window.location.search; - url = decodeURIComponent( url.slice( url.indexOf("swarmURL=") + 9 ) ); - if ( !url || url.indexOf("http") !== 0 ) { - return; - } - document.write( "" ); -})(); diff --git a/tests/unit/testsuite.js b/tests/unit/testsuite.js deleted file mode 100644 index 59e40af43e5..00000000000 --- a/tests/unit/testsuite.js +++ /dev/null @@ -1,346 +0,0 @@ -(function( $ ) { - -var reset, jshintLoaded; - -window.TestHelpers = {}; - -function includeStyle( url ) { - document.write( "" ); -} - -function includeScript( url ) { - document.write( "" ); -} - -function url( value ) { - return value + ( /\?/.test( value ) ? "&" : "?" ) + new Date().getTime() + "" + - parseInt( Math.random() * 100000, 10 ); -} - -reset = QUnit.reset; -QUnit.reset = function() { - - // Ensure jQuery events and data on the fixture are properly removed - jQuery( "#qunit-fixture" ).empty(); - - // Let QUnit reset the fixture - reset.apply( this, arguments ); -}; - -QUnit.config.requireExpects = true; - -/* -// TODO: Add back the ability to test against minified files -// see QUnit.urlParams.min usage below -QUnit.config.urlConfig.push({ - id: "min", - label: "Minified source", - tooltip: "Load minified source files instead of the regular unminified ones." -}); -*/ - -TestHelpers.loadResources = QUnit.urlParams.min ? - function() { - includeStyle( "dist/jquery-ui.min.css" ); - includeScript( "dist/jquery-ui.min.js" ); - } : - function( resources ) { - $.each( resources.css || [], function( i, resource ) { - includeStyle( "themes/base/" + resource + ".css" ); - }); - $.each( resources.js || [], function( i, resource ) { - includeScript( resource ); - }); - }; - -QUnit.config.urlConfig.push({ - id: "nojshint", - label: "Skip JSHint", - tooltip: "Skip running JSHint, e.g., within TestSwarm, where Jenkins runs it already" -}); - -QUnit.config.urlConfig.push({ - id: "jquery", - label: "jQuery version", - value: [ - "1.7.0", "1.7.1", "1.7.2", - "1.8.0", "1.8.1", "1.8.2", "1.8.3", - "1.9.0", "1.9.1", - "1.10.0", "1.10.1", "1.10.2", - "1.11.0", "1.11.1", "1.11.2", - "2.0.0", "2.0.1", "2.0.2", "2.0.3", - "2.1.0", "2.1.1", "2.1.2", "2.1.3", - "git1", "git" - ], - tooltip: "Which jQuery Core version to test against" -}); - -jshintLoaded = false; -TestHelpers.testJshint = function( module ) { - - // Function.prototype.bind check is needed because JSHint doesn't work in ES3 browsers anymore - // https://github.com/jshint/jshint/issues/1384 - if ( QUnit.urlParams.nojshint || !Function.prototype.bind ) { - return; - } - - if ( !jshintLoaded ) { - includeScript( "external/jshint/jshint.js" ); - jshintLoaded = true; - } - - asyncTest( "JSHint", function() { - expect( 1 ); - - $.when( - $.ajax({ - url: url( "../../../ui/.jshintrc" ), - dataType: "json" - }), - $.ajax({ - url: url( "../../../ui/" + module + ".js" ), - dataType: "text" - }) - ).done(function( hintArgs, srcArgs ) { - var globals, passed, errors, - jshintrc = hintArgs[ 0 ], - source = srcArgs[ 0 ]; - - globals = jshintrc.globals || {}; - delete jshintrc.globals; - passed = JSHINT( source, jshintrc, globals ); - errors = $.map( JSHINT.errors, function( error ) { - - // JSHINT may report null if there are too many errors - if ( !error ) { - return; - } - - return "[L" + error.line + ":C" + error.character + "] " + - error.reason + "\n" + error.evidence + "\n"; - }).join( "\n" ); - ok( passed, errors ); - start(); - }) - .fail(function() { - ok( false, "error loading source" ); - start(); - }); - }); -}; - -function testWidgetDefaults( widget, defaults ) { - var pluginDefaults = $.ui[ widget ].prototype.options; - - // Ensure that all defaults have the correct value - test( "defined defaults", function() { - var count = 0; - $.each( defaults, function( key, val ) { - expect( ++count ); - if ( $.isFunction( val ) ) { - ok( $.isFunction( pluginDefaults[ key ] ), key ); - return; - } - deepEqual( pluginDefaults[ key ], val, key ); - }); - }); - - // Ensure that all defaults were tested - test( "tested defaults", function() { - var count = 0; - $.each( pluginDefaults, function( key ) { - expect( ++count ); - ok( key in defaults, key ); - }); - }); -} - -function testWidgetOverrides( widget ) { - if ( $.uiBackCompat === false ) { - test( "$.widget overrides", function() { - expect( 4 ); - $.each([ - "_createWidget", - "destroy", - "option", - "_trigger" - ], function( i, method ) { - strictEqual( $.ui[ widget ].prototype[ method ], - $.Widget.prototype[ method ], "should not override " + method ); - }); - }); - } -} - -function testBasicUsage( widget ) { - test( "basic usage", function() { - expect( 3 ); - - var defaultElement = $.ui[ widget ].prototype.defaultElement; - $( defaultElement ).appendTo( "body" )[ widget ]().remove(); - ok( true, "initialized on element" ); - - $( defaultElement )[ widget ]().remove(); - ok( true, "initialized on disconnected DOMElement - never connected" ); - - // Ensure manipulating removed elements works (#3664) - $( defaultElement ).appendTo( "body" ).remove()[ widget ]().remove(); - ok( true, "initialized on disconnected DOMElement - removed" ); - }); -} - -TestHelpers.commonWidgetTests = function( widget, settings ) { - module( widget + ": common widget" ); - - TestHelpers.testJshint( widget ); - testWidgetDefaults( widget, settings.defaults ); - testWidgetOverrides( widget ); - testBasicUsage( widget ); - test( "version", function() { - expect( 1 ); - ok( "version" in $.ui[ widget ].prototype, "version property exists" ); - }); -}; - -TestHelpers.onFocus = function( element, onFocus ) { - var fn = function( event ) { - if ( !event.originalEvent ) { - return; - } - element.unbind( "focus", fn ); - onFocus(); - }; - - element.bind( "focus", fn )[ 0 ].focus(); -}; - -TestHelpers.forceScrollableWindow = function( appendTo ) { - - // The main testable area is 10000x10000 so to enforce scrolling, - // this DIV must be greater than 10000 to work - return $( "
" ).css({ - height: "11000px", - width: "11000px" - }).appendTo( appendTo || "#qunit-fixture" ); -}; - -// TODO: switch to qunit-assert-close plugin -QUnit.assert.close = function( actual, expected, maxDifference, message ) { - var passes = ( actual === expected ) || Math.abs( actual - expected ) <= maxDifference; - QUnit.push( passes, actual, expected, message ); -}; - -/* - * Experimental assertion for comparing DOM objects. - * - * Serializes an element and some properties and attributes and its children if any, - * otherwise the text. Then compares the result using deepEqual(). - */ -window.domEqual = function( selector, modifier, message ) { - var expected, actual, - properties = [ - "disabled", - "readOnly" - ], - attributes = [ - "autocomplete", - "aria-activedescendant", - "aria-controls", - "aria-describedby", - "aria-disabled", - "aria-expanded", - "aria-haspopup", - "aria-hidden", - "aria-labelledby", - "aria-pressed", - "aria-selected", - "aria-valuemax", - "aria-valuemin", - "aria-valuenow", - "class", - "href", - "id", - "nodeName", - "role", - "tabIndex", - "title" - ]; - - function getElementStyles( elem ) { - var key, len, - style = elem.ownerDocument.defaultView ? - elem.ownerDocument.defaultView.getComputedStyle( elem, null ) : - elem.currentStyle, - styles = {}; - - if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) { - len = style.length; - while ( len-- ) { - key = style[ len ]; - if ( typeof style[ key ] === "string" ) { - styles[ $.camelCase( key ) ] = style[ key ]; - } - } - - // support: Opera, IE <9 - } else { - for ( key in style ) { - if ( typeof style[ key ] === "string" ) { - styles[ key ] = style[ key ]; - } - } - } - - return styles; - } - - function extract( elem ) { - if ( !elem || !elem.length ) { - QUnit.push( false, actual, expected, - "domEqual failed, can't extract " + selector + ", message was: " + message ); - return; - } - - var children, - result = {}; - $.each( properties, function( index, attr ) { - var value = elem.prop( attr ); - result[ attr ] = value != null ? value : ""; - }); - $.each( attributes, function( index, attr ) { - var value = elem.attr( attr ); - result[ attr ] = value != null ? value : ""; - }); - result.style = getElementStyles( elem[ 0 ] ); - result.events = $._data( elem[ 0 ], "events" ); - result.data = $.extend( {}, elem.data() ); - delete result.data[ $.expando ]; - children = elem.children(); - if ( children.length ) { - result.children = elem.children().map(function() { - return extract( $( this ) ); - }).get(); - } else { - result.text = elem.text(); - } - return result; - } - - function done() { - actual = extract( $( selector ) ); - QUnit.push( QUnit.equiv(actual, expected), actual, expected, message ); - } - - // Get current state prior to modifier - expected = extract( $( selector ) ); - - // Run modifier (async or sync), then compare state via done() - if ( modifier.length ) { - modifier( done ); - } else { - modifier(); - done(); - } -}; - -}( jQuery )); From ca04a6ffc35cf49ea80b711aaa80cf14d31d3623 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Tue, 7 Apr 2015 10:30:07 -0400 Subject: [PATCH 26/29] Tests: Widget test helpers extend the main helper --- tests/unit/accordion/accordion_core.js | 6 +- tests/unit/accordion/accordion_events.js | 6 +- tests/unit/accordion/accordion_methods.js | 8 +- tests/unit/accordion/accordion_options.js | 8 +- .../unit/accordion/accordion_test_helpers.js | 11 +- tests/unit/datepicker/datepicker_core.js | 128 +++++----- tests/unit/datepicker/datepicker_events.js | 14 +- tests/unit/datepicker/datepicker_methods.js | 40 +-- tests/unit/datepicker/datepicker_options.js | 240 +++++++++--------- .../datepicker/datepicker_test_helpers.js | 16 +- tests/unit/dialog/dialog_events.js | 14 +- tests/unit/dialog/dialog_options.js | 50 ++-- tests/unit/dialog/dialog_test_helpers.js | 16 +- tests/unit/draggable/draggable_core.js | 31 ++- tests/unit/draggable/draggable_methods.js | 18 +- tests/unit/draggable/draggable_options.js | 234 ++++++++--------- .../unit/draggable/draggable_test_helpers.js | 44 +++- tests/unit/droppable/droppable_core.js | 4 +- tests/unit/droppable/droppable_methods.js | 18 +- tests/unit/droppable/droppable_options.js | 1 - .../unit/droppable/droppable_test_helpers.js | 10 +- tests/unit/menu/menu_core.js | 4 +- tests/unit/menu/menu_events.js | 10 +- tests/unit/menu/menu_methods.js | 10 +- tests/unit/menu/menu_options.js | 10 +- tests/unit/menu/menu_test_helpers.js | 9 +- tests/unit/resizable/resizable_core.js | 50 ++-- tests/unit/resizable/resizable_events.js | 20 +- tests/unit/resizable/resizable_options.js | 102 ++++---- .../unit/resizable/resizable_test_helpers.js | 9 +- tests/unit/sortable/sortable_core.js | 4 +- tests/unit/sortable/sortable_events.js | 4 +- tests/unit/sortable/sortable_methods.js | 14 +- tests/unit/sortable/sortable_test_helpers.js | 9 +- tests/unit/spinner/spinner_core.js | 4 +- tests/unit/spinner/spinner_events.js | 4 +- tests/unit/spinner/spinner_methods.js | 4 +- tests/unit/spinner/spinner_test_helpers.js | 9 +- tests/unit/tabs/tabs_core.js | 4 +- tests/unit/tabs/tabs_events.js | 4 +- tests/unit/tabs/tabs_methods.js | 6 +- tests/unit/tabs/tabs_options.js | 8 +- tests/unit/tabs/tabs_test_helpers.js | 10 +- 43 files changed, 635 insertions(+), 590 deletions(-) diff --git a/tests/unit/accordion/accordion_core.js b/tests/unit/accordion/accordion_core.js index 474943098d0..bd3b5675220 100644 --- a/tests/unit/accordion/accordion_core.js +++ b/tests/unit/accordion/accordion_core.js @@ -2,10 +2,10 @@ define( [ "jquery", "./accordion_test_helpers", "ui/accordion" -], function( $, accordionTestHelper ) { +], function( $, testHelper ) { -var setupTeardown = accordionTestHelper.setupTeardown, - state = accordionTestHelper.state; +var setupTeardown = testHelper.setupTeardown, + state = testHelper.state; module( "accordion: core", setupTeardown() ); diff --git a/tests/unit/accordion/accordion_events.js b/tests/unit/accordion/accordion_events.js index 05dc144b428..ac05df30d34 100644 --- a/tests/unit/accordion/accordion_events.js +++ b/tests/unit/accordion/accordion_events.js @@ -2,10 +2,10 @@ define( [ "jquery", "./accordion_test_helpers", "ui/accordion" -], function( $, accordionTestHelper ) { +], function( $, testHelper ) { -var setupTeardown = accordionTestHelper.setupTeardown, - state = accordionTestHelper.state; +var setupTeardown = testHelper.setupTeardown, + state = testHelper.state; module( "accordion: events", setupTeardown() ); diff --git a/tests/unit/accordion/accordion_methods.js b/tests/unit/accordion/accordion_methods.js index 5fdb115c63c..f33996c36e5 100644 --- a/tests/unit/accordion/accordion_methods.js +++ b/tests/unit/accordion/accordion_methods.js @@ -2,11 +2,11 @@ define( [ "jquery", "./accordion_test_helpers", "ui/accordion" -], function( $, accordionTestHelper ) { +], function( $, testHelper ) { -var equalHeight = accordionTestHelper.equalHeight, - setupTeardown = accordionTestHelper.setupTeardown, - state = accordionTestHelper.state; +var equalHeight = testHelper.equalHeight, + setupTeardown = testHelper.setupTeardown, + state = testHelper.state; module( "accordion: methods", setupTeardown() ); diff --git a/tests/unit/accordion/accordion_options.js b/tests/unit/accordion/accordion_options.js index 3235057dc3e..d33241dac60 100644 --- a/tests/unit/accordion/accordion_options.js +++ b/tests/unit/accordion/accordion_options.js @@ -2,11 +2,11 @@ define( [ "jquery", "./accordion_test_helpers", "ui/accordion" -], function( $, accordionTestHelper ) { +], function( $, testHelper ) { -var equalHeight = accordionTestHelper.equalHeight, - setupTeardown = accordionTestHelper.setupTeardown, - state = accordionTestHelper.state; +var equalHeight = testHelper.equalHeight, + setupTeardown = testHelper.setupTeardown, + state = testHelper.state; module( "accordion: options", setupTeardown() ); diff --git a/tests/unit/accordion/accordion_test_helpers.js b/tests/unit/accordion/accordion_test_helpers.js index ec1190f16e5..5eb3a4bc3f2 100644 --- a/tests/unit/accordion/accordion_test_helpers.js +++ b/tests/unit/accordion/accordion_test_helpers.js @@ -1,6 +1,10 @@ -define( function() { +define( [ + "jquery", + "lib/helper", + "ui/accordion" +], function( $, helper ) { -return { +return $.extend( helper, { equalHeight: function( accordion, height ) { accordion.find( ".ui-accordion-content" ).each(function() { equal( $( this ).outerHeight(), height ); @@ -26,7 +30,6 @@ return { }).get(); QUnit.push( QUnit.equiv(actual, expected), actual, expected ); } - -}; +} ); } ); diff --git a/tests/unit/datepicker/datepicker_core.js b/tests/unit/datepicker/datepicker_core.js index 3ed4b9487f3..a1e75848ab8 100644 --- a/tests/unit/datepicker/datepicker_core.js +++ b/tests/unit/datepicker/datepicker_core.js @@ -4,7 +4,7 @@ define( [ "./datepicker_test_helpers", "ui/datepicker", "ui/i18n/datepicker-he" -], function( $, common, datepickerTestHelpers ) { +], function( $, common, testHelper ) { module( "datepicker: core", { setup: function() { @@ -39,11 +39,11 @@ test("widget method", function() { asyncTest( "baseStructure", function() { expect( 58 ); var header, title, table, thead, week, panel, inl, child, - inp = datepickerTestHelpers.initNewInput(), + inp = testHelper.initNewInput(), dp = $( "#ui-datepicker-div" ); function step1() { - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( dp.is( ":visible" ), "Structure - datepicker visible" ); ok( !dp.is( ".ui-datepicker-rtl" ), "Structure - not right-to-left" ); ok( !dp.is( ".ui-datepicker-multi" ), "Structure - not multi-month" ); @@ -84,12 +84,12 @@ asyncTest( "baseStructure", function() { function step2() { // Editable month/year and button panel - inp = datepickerTestHelpers.initNewInput({ + inp = testHelper.initNewInput({ changeMonth: true, changeYear: true, showButtonPanel: true }); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { title = dp.find( "div.ui-datepicker-title" ); ok( title.children( ":first" ).is( "select.ui-datepicker-month" ), "Structure - month selector" ); ok( title.children( ":last" ).is( "select.ui-datepicker-year" ), "Structure - year selector" ); @@ -107,8 +107,8 @@ asyncTest( "baseStructure", function() { function step3() { // Multi-month 2 - inp = datepickerTestHelpers.initNewInput({ numberOfMonths: 2 }); - datepickerTestHelpers.onFocus( inp, function() { + inp = testHelper.initNewInput({ numberOfMonths: 2 }); + testHelper.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi" ), "Structure multi [2] - multi-month" ); equal( dp.children().length, 3, "Structure multi [2] - child count" ); @@ -129,8 +129,8 @@ asyncTest( "baseStructure", function() { function step4() { // Multi-month 3 - inp = datepickerTestHelpers.initNewInput({ numberOfMonths: 3 }); - datepickerTestHelpers.onFocus( inp, function() { + inp = testHelper.initNewInput({ numberOfMonths: 3 }); + testHelper.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi-3" ), "Structure multi [3] - multi-3" ); ok( !dp.is( ".ui-datepicker-multi-2" ), "Structure multi [3] - Trac #6704" ); @@ -141,8 +141,8 @@ asyncTest( "baseStructure", function() { function step5() { // Multi-month [2, 2] - inp = datepickerTestHelpers.initNewInput({ numberOfMonths: [ 2, 2 ] }); - datepickerTestHelpers.onFocus( inp, function() { + inp = testHelper.initNewInput({ numberOfMonths: [ 2, 2 ] }); + testHelper.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-multi" ), "Structure multi - multi-month" ); equal( dp.children().length, 6, "Structure multi [2,2] - child count" ); @@ -167,7 +167,7 @@ asyncTest( "baseStructure", function() { inp.datepicker( "hide" ).datepicker( "destroy" ); // Inline - inl = datepickerTestHelpers.init( "#inl" ); + inl = testHelper.init( "#inl" ); dp = inl.children(); ok( dp.is( ".ui-datepicker-inline" ), "Structure inline - main div" ); @@ -187,7 +187,7 @@ asyncTest( "baseStructure", function() { inl.datepicker( "destroy" ); // Inline multi-month - inl = datepickerTestHelpers.init( "#inl", { numberOfMonths: 2 } ); + inl = testHelper.init( "#inl", { numberOfMonths: 2 } ); dp = inl.children(); ok( dp.is( ".ui-datepicker-inline" ) && dp.is( ".ui-datepicker-multi" ), "Structure inline multi - main div" ); @@ -213,13 +213,13 @@ asyncTest( "baseStructure", function() { asyncTest( "customStructure", function() { expect( 20 ); var header, panel, title, thead, - inp = datepickerTestHelpers.initNewInput( $.datepicker.regional.he ), + inp = testHelper.initNewInput( $.datepicker.regional.he ), dp = $( "#ui-datepicker-div" ); function step1() { inp.datepicker( "option", "showButtonPanel", true ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( dp.is( ".ui-datepicker-rtl" ), "Structure RTL - right-to-left" ); header = dp.children( ":first" ); @@ -241,14 +241,14 @@ asyncTest( "customStructure", function() { // Hide prev/next function step2() { - inp = datepickerTestHelpers.initNewInput({ + inp = testHelper.initNewInput({ hideIfNoPrevNext: true, minDate: new Date( 2008, 2 - 1, 4 ), maxDate: new Date( 2008, 2 - 1, 14 ) }); inp.val( "02/10/2008" ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { header = dp.children( ":first" ); ok( header.is( "div.ui-datepicker-header" ), "Structure hide prev/next - header division" ); equal( header.children().length, 1, "Structure hide prev/next - links child count" ); @@ -261,9 +261,9 @@ asyncTest( "customStructure", function() { // Changeable Month with read-only year function step3() { - inp = datepickerTestHelpers.initNewInput({ changeMonth: true }); + inp = testHelper.initNewInput({ changeMonth: true }); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { title = dp.children( ":first" ).children( ":last" ); equal( title.children().length, 2, "Structure changeable month - title child count" ); ok( title.children( ":first" ).is( "select.ui-datepicker-month" ), "Structure changeable month - month selector" ); @@ -276,9 +276,9 @@ asyncTest( "customStructure", function() { // Changeable year with read-only month function step4() { - inp = datepickerTestHelpers.initNewInput({ changeYear: true }); + inp = testHelper.initNewInput({ changeYear: true }); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { title = dp.children( ":first" ).children( ":last" ); equal( title.children().length, 2, "Structure changeable year - title child count" ); ok( title.children( ":first" ).is( "span.ui-datepicker-month" ), "Structure changeable year - read-only month" ); @@ -291,9 +291,9 @@ asyncTest( "customStructure", function() { // Read-only first day of week function step5() { - inp = datepickerTestHelpers.initNewInput({ changeFirstDay: false }); + inp = testHelper.initNewInput({ changeFirstDay: false }); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { thead = dp.find( ".ui-datepicker-calendar thead tr" ); equal( thead.children().length, 7, "Structure read-only first day - thead child count" ); equal( thead.find( "a" ).length, 0, "Structure read-only first day - thead links count" ); @@ -311,19 +311,19 @@ asyncTest( "customStructure", function() { test("keystrokes", function() { expect( 26 ); - var inp = datepickerTestHelpers.init("#inp"), + var inp = testHelper.init("#inp"), date = new Date(); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke enter"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke enter"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke enter - preset"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.HOME}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+home"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+home"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.END}); ok(inp.datepicker("getDate") == null, "Keystroke ctrl+end"); @@ -332,95 +332,95 @@ test("keystrokes", function() { ok(inp.datepicker("getDate") == null, "Keystroke esc"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke esc - preset"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke esc - abandoned"); // Moving by day or week inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.LEFT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+left"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+left"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.LEFT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke left"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke left"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.RIGHT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+right"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+right"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.RIGHT}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke right"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke right"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 7); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+up"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+up"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 7); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke up"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke up"); inp.val("").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 7); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+down"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke ctrl+down"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 7); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Keystroke down"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Keystroke down"); // Moving by month or year inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 4), "Keystroke pgup"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 4), "Keystroke pgdn"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 4), "Keystroke ctrl+pgup"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 4), "Keystroke ctrl+pgdn"); // Check for moving to short months inp.val("03/31/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), "Keystroke pgup - Feb"); inp.val("01/30/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 29), "Keystroke pgdn - Feb"); inp.val("02/29/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 28), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2007, 2 - 1, 28), "Keystroke ctrl+pgup - Feb"); inp.val("02/29/2008").datepicker("show"). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 28), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2009, 2 - 1, 28), "Keystroke ctrl+pgdn - Feb"); // Goto current inp.datepicker("option", {gotoCurrent: true}). @@ -428,35 +428,35 @@ test("keystrokes", function() { simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.HOME}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Keystroke ctrl+home"); // Change steps inp.datepicker("option", {stepMonths: 2, gotoCurrent: false}). datepicker("hide").val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2007, 12 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2007, 12 - 1, 4), "Keystroke pgup step 2"); inp.val("02/04/2008").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 4 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 4 - 1, 4), "Keystroke pgdn step 2"); }); test("mouse", function() { expect( 15 ); var inl, - inp = datepickerTestHelpers.init("#inp"), + inp = testHelper.init("#inp"), dp = $("#ui-datepicker-div"), date = new Date(); inp.val("").datepicker("show"); $(".ui-datepicker-calendar tbody a:contains(10)", dp).simulate("click", {}); date.setDate(10); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Mouse click"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Mouse click"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-calendar tbody a:contains(12)", dp).simulate("click", {}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 12), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click - preset"); inp.val("02/04/2008").datepicker("show"); inp.val("").datepicker("show"); @@ -464,66 +464,66 @@ test("mouse", function() { ok(inp.datepicker("getDate") == null, "Mouse click - close"); inp.val("02/04/2008").datepicker("show"); $("button.ui-datepicker-close", dp).simulate("click", {}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Mouse click - close + preset"); inp.val("02/04/2008").datepicker("show"); $("a.ui-datepicker-prev", dp).simulate("click", {}); $("button.ui-datepicker-close", dp).simulate("click", {}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 4), "Mouse click - abandoned"); // Current/previous/next inp.val("02/04/2008").datepicker("option", {showButtonPanel: true}).datepicker("show"); $(".ui-datepicker-current", dp).simulate("click", {}); $(".ui-datepicker-calendar tbody a:contains(14)", dp).simulate("click", {}); date.setDate(14); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Mouse click - current"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Mouse click - current"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 16), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 1 - 1, 16), "Mouse click - previous"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 18), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 3 - 1, 18), "Mouse click - next"); // Previous/next with minimum/maximum inp.datepicker("option", {minDate: new Date(2008, 2 - 1, 2), maxDate: new Date(2008, 2 - 1, 26)}).val("02/04/2008").datepicker("show"); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 16), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 16), "Mouse click - previous + min/max"); inp.val("02/04/2008").datepicker("show"); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 18), + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 2 - 1, 18), "Mouse click - next + min/max"); // Inline - inl = datepickerTestHelpers.init("#inl"); + inl = testHelper.init("#inl"); dp = $(".ui-datepicker-inline", inl); date = new Date(); inl.datepicker("setDate", date); $(".ui-datepicker-calendar tbody a:contains(10)", dp).simulate("click", {}); date.setDate(10); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline"); + testHelper.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline"); inl.datepicker("option", {showButtonPanel: true}).datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-calendar tbody a:contains(12)", dp).simulate("click", {}); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click inline - preset"); + testHelper.equalsDate(inl.datepicker("getDate"), new Date(2008, 2 - 1, 12), "Mouse click inline - preset"); inl.datepicker("option", {showButtonPanel: true}); $(".ui-datepicker-current", dp).simulate("click", {}); $(".ui-datepicker-calendar tbody a:contains(14)", dp).simulate("click", {}); date.setDate(14); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline - current"); + testHelper.equalsDate(inl.datepicker("getDate"), date, "Mouse click inline - current"); inl.datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-prev", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(16)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 1 - 1, 16), + testHelper.equalsDate(inl.datepicker("getDate"), new Date(2008, 1 - 1, 16), "Mouse click inline - previous"); inl.datepicker("setDate", new Date(2008, 2 - 1, 4)); $(".ui-datepicker-next", dp).simulate("click"); $(".ui-datepicker-calendar tbody a:contains(18)", dp).simulate("click"); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), new Date(2008, 3 - 1, 18), + testHelper.equalsDate(inl.datepicker("getDate"), new Date(2008, 3 - 1, 18), "Mouse click inline - next"); }); diff --git a/tests/unit/datepicker/datepicker_events.js b/tests/unit/datepicker/datepicker_events.js index b012f647d41..04a4cbfe845 100644 --- a/tests/unit/datepicker/datepicker_events.js +++ b/tests/unit/datepicker/datepicker_events.js @@ -2,7 +2,7 @@ define( [ "jquery", "./datepicker_test_helpers", "ui/datepicker" -], function( $, datepickerTestHelpers ) { +], function( $, testHelper ) { module("datepicker: events"); @@ -25,13 +25,13 @@ function callback2(year, month, inst) { test("events", function() { expect( 26 ); var dateStr, newMonthYear, inp2, - inp = datepickerTestHelpers.init("#inp", {onSelect: callback}), + inp = testHelper.init("#inp", {onSelect: callback}), date = new Date(); // onSelect inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); equal(selectedThis, inp[0], "Callback selected this"); - equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback selected inst"); + equal(selectedInst, $.data(inp[0], testHelper.PROP_NAME), "Callback selected inst"); equal(selectedDate, $.datepicker.formatDate("mm/dd/yy", date), "Callback selected date"); inp.val("").datepicker("show"). @@ -60,7 +60,7 @@ test("events", function() { inp.simulate("keydown", {keyCode: $.ui.keyCode.PAGE_UP}); date.setMonth(date.getMonth() - 1); equal(selectedThis, inp[0], "Callback change month/year this"); - equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback change month/year inst"); + equal(selectedInst, $.data(inp[0], testHelper.PROP_NAME), "Callback change month/year inst"); equal(selectedDate, newMonthYear(date), "Callback change month/year date - pgup"); inp.simulate("keydown", {keyCode: $.ui.keyCode.PAGE_DOWN}); @@ -108,7 +108,7 @@ test("events", function() { val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ESCAPE}); equal(selectedThis, inp[0], "Callback close this"); - equal(selectedInst, $.data(inp[0], datepickerTestHelpers.PROP_NAME), "Callback close inst"); + equal(selectedInst, $.data(inp[0], testHelper.PROP_NAME), "Callback close inst"); equal(selectedDate, "", "Callback close date - esc"); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); @@ -121,7 +121,7 @@ test("events", function() { simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.END}); equal(selectedDate, "", "Callback close date - ctrl+end"); - inp2 = datepickerTestHelpers.init("#inp2"); + inp2 = testHelper.init("#inp2"); inp2.datepicker().datepicker("option", {onClose: callback}).datepicker("show"); inp.datepicker("show"); equal(selectedThis, inp2[0], "Callback close this"); @@ -129,7 +129,7 @@ test("events", function() { test("beforeShowDay-getDate", function() { expect( 3 ); - var inp = datepickerTestHelpers.init("#inp", {beforeShowDay: function() { inp.datepicker("getDate"); return [true, ""]; }}), + var inp = testHelper.init("#inp", {beforeShowDay: function() { inp.datepicker("getDate"); return [true, ""]; }}), dp = $("#ui-datepicker-div"); inp.val("01/01/2010").datepicker("show"); // contains non-breaking space diff --git a/tests/unit/datepicker/datepicker_methods.js b/tests/unit/datepicker/datepicker_methods.js index c16376880aa..3899779a9c7 100644 --- a/tests/unit/datepicker/datepicker_methods.js +++ b/tests/unit/datepicker/datepicker_methods.js @@ -2,72 +2,72 @@ define( [ "jquery", "./datepicker_test_helpers", "ui/datepicker" -], function( $, datepickerTestHelpers ) { +], function( $, testHelper ) { module("datepicker: methods"); test("destroy", function() { expect( 33 ); var inl, - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); ok(inp.is(".hasDatepicker"), "Default - marker class set"); - ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Default - instance present"); + ok($.data(inp[0], testHelper.PROP_NAME), "Default - instance present"); ok(inp.next().is("#alt"), "Default - button absent"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Default - marker class cleared"); - ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Default - instance absent"); + ok(!$.data(inp[0], testHelper.PROP_NAME), "Default - instance absent"); ok(inp.next().is("#alt"), "Default - button absent"); // With button - inp= datepickerTestHelpers.init("#inp", {showOn: "both"}); + inp= testHelper.init("#inp", {showOn: "both"}); ok(inp.is(".hasDatepicker"), "Button - marker class set"); - ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Button - instance present"); + ok($.data(inp[0], testHelper.PROP_NAME), "Button - instance present"); ok(inp.next().text() === "...", "Button - button added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Button - marker class cleared"); - ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Button - instance absent"); + ok(!$.data(inp[0], testHelper.PROP_NAME), "Button - instance absent"); ok(inp.next().is("#alt"), "Button - button removed"); // With append text - inp = datepickerTestHelpers.init("#inp", {appendText: "Testing"}); + inp = testHelper.init("#inp", {appendText: "Testing"}); ok(inp.is(".hasDatepicker"), "Append - marker class set"); - ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Append - instance present"); + ok($.data(inp[0], testHelper.PROP_NAME), "Append - instance present"); ok(inp.next().text() === "Testing", "Append - append text added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Append - marker class cleared"); - ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Append - instance absent"); + ok(!$.data(inp[0], testHelper.PROP_NAME), "Append - instance absent"); ok(inp.next().is("#alt"), "Append - append text removed"); // With both - inp= datepickerTestHelpers.init("#inp", {showOn: "both", buttonImageOnly: true, + inp= testHelper.init("#inp", {showOn: "both", buttonImageOnly: true, buttonImage: "images/calendar.gif", appendText: "Testing"}); ok(inp.is(".hasDatepicker"), "Both - marker class set"); - ok($.data(inp[0], datepickerTestHelpers.PROP_NAME), "Both - instance present"); + ok($.data(inp[0], testHelper.PROP_NAME), "Both - instance present"); ok(inp.next()[0].nodeName.toLowerCase() === "img", "Both - button added"); ok(inp.next().next().text() === "Testing", "Both - append text added"); inp.datepicker("destroy"); inp = $("#inp"); ok(!inp.is(".hasDatepicker"), "Both - marker class cleared"); - ok(!$.data(inp[0], datepickerTestHelpers.PROP_NAME), "Both - instance absent"); + ok(!$.data(inp[0], testHelper.PROP_NAME), "Both - instance absent"); ok(inp.next().is("#alt"), "Both - button and append text absent"); // Inline - inl = datepickerTestHelpers.init("#inl"); + inl = testHelper.init("#inl"); ok(inl.is(".hasDatepicker"), "Inline - marker class set"); ok(inl.html() !== "", "Inline - datepicker present"); - ok($.data(inl[0], datepickerTestHelpers.PROP_NAME), "Inline - instance present"); + ok($.data(inl[0], testHelper.PROP_NAME), "Inline - instance present"); ok(inl.next().length === 0 || inl.next().is("p"), "Inline - button absent"); inl.datepicker("destroy"); inl = $("#inl"); ok(!inl.is(".hasDatepicker"), "Inline - marker class cleared"); ok(inl.html() === "", "Inline - datepicker absent"); - ok(!$.data(inl[0], datepickerTestHelpers.PROP_NAME), "Inline - instance absent"); + ok(!$.data(inl[0], testHelper.PROP_NAME), "Inline - instance absent"); ok(inl.next().length === 0 || inl.next().is("p"), "Inline - button absent"); }); test("enableDisable", function() { expect( 33 ); var inl, dp, - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); ok(!inp.datepicker("isDisabled"), "Enable/disable - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable - field initially enabled"); inp.datepicker("disable"); @@ -78,7 +78,7 @@ test("enableDisable", function() { ok(!inp[0].disabled, "Enable/disable - field now enabled"); inp.datepicker("destroy"); // With a button - inp = datepickerTestHelpers.init("#inp", {showOn: "button"}); + inp = testHelper.init("#inp", {showOn: "button"}); ok(!inp.datepicker("isDisabled"), "Enable/disable button - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable button - field initially enabled"); ok(!inp.next("button")[0].disabled, "Enable/disable button - button initially enabled"); @@ -92,7 +92,7 @@ test("enableDisable", function() { ok(!inp.next("button")[0].disabled, "Enable/disable button - button now enabled"); inp.datepicker("destroy"); // With an image button - inp = datepickerTestHelpers.init("#inp", {showOn: "button", buttonImageOnly: true, + inp = testHelper.init("#inp", {showOn: "button", buttonImageOnly: true, buttonImage: "images/calendar.gif"}); ok(!inp.datepicker("isDisabled"), "Enable/disable image - initially marked as enabled"); ok(!inp[0].disabled, "Enable/disable image - field initially enabled"); @@ -107,7 +107,7 @@ test("enableDisable", function() { ok(parseFloat(inp.next("img").css("opacity")) === 1, "Enable/disable image - image now enabled"); inp.datepicker("destroy"); // Inline - inl = datepickerTestHelpers.init("#inl", {changeYear: true}); + inl = testHelper.init("#inl", {changeYear: true}); dp = $(".ui-datepicker-inline", inl); ok(!inl.datepicker("isDisabled"), "Enable/disable inline - initially marked as enabled"); ok(!dp.children().is(".ui-state-disabled"), "Enable/disable inline - not visually disabled initially"); diff --git a/tests/unit/datepicker/datepicker_options.js b/tests/unit/datepicker/datepicker_options.js index 20a7b4d80b8..ee4a3bae462 100644 --- a/tests/unit/datepicker/datepicker_options.js +++ b/tests/unit/datepicker/datepicker_options.js @@ -5,13 +5,13 @@ define( [ "ui/i18n/datepicker-fr", "ui/i18n/datepicker-he", "ui/i18n/datepicker-zh-CN" -], function( $, datepickerTestHelpers ) { +], function( $, testHelper ) { module("datepicker: options"); test("setDefaults", function() { expect( 3 ); - datepickerTestHelpers.init("#inp"); + testHelper.init("#inp"); equal($.datepicker._defaults.showOn, "focus", "Initial showOn"); $.datepicker.setDefaults({showOn: "button"}); equal($.datepicker._defaults.showOn, "button", "Change default showOn"); @@ -21,8 +21,8 @@ test("setDefaults", function() { test("option", function() { expect( 17 ); - var inp = datepickerTestHelpers.init("#inp"), - inst = $.data(inp[0], datepickerTestHelpers.PROP_NAME); + var inp = testHelper.init("#inp"), + inst = $.data(inp[0], testHelper.PROP_NAME); // Set option equal(inst.settings.showOn, null, "Initial setting showOn"); equal($.datepicker._get(inst, "showOn"), "focus", "Initial instance showOn"); @@ -40,7 +40,7 @@ test("option", function() { equal($.datepicker._get(inst, "showOn"), "focus", "Restore instance showOn"); equal($.datepicker._defaults.showOn, "focus", "Retain default showOn"); // Get option - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); equal(inp.datepicker("option", "showOn"), "focus", "Initial setting showOn"); inp.datepicker("option", "showOn", "button"); equal(inp.datepicker("option", "showOn"), "button", "Change instance showOn"); @@ -53,7 +53,7 @@ test("option", function() { test( "disabled", function() { expect(8); - var inp = datepickerTestHelpers.init("#inp"); + var inp = testHelper.init("#inp"); ok(!inp.datepicker("isDisabled"), "Initially marked as enabled"); ok(!inp[0].disabled, "Field initially enabled"); inp.datepicker("option", "disabled", true); @@ -64,15 +64,15 @@ test( "disabled", function() { ok(!inp[0].disabled, "Field now enabled"); inp.datepicker("destroy"); - inp = datepickerTestHelpers.init("#inp", { disabled: true }); + inp = testHelper.init("#inp", { disabled: true }); ok(inp.datepicker("isDisabled"), "Initially marked as disabled"); ok(inp[0].disabled, "Field initially disabled"); }); test("change", function() { expect( 12 ); - var inp = datepickerTestHelpers.init("#inp"), - inst = $.data(inp[0], datepickerTestHelpers.PROP_NAME); + var inp = testHelper.init("#inp"), + inst = $.data(inp[0], testHelper.PROP_NAME); equal(inst.settings.showOn, null, "Initial setting showOn"); equal($.datepicker._get(inst, "showOn"), "focus", "Initial instance showOn"); equal($.datepicker._defaults.showOn, "focus", "Initial default showOn"); @@ -107,7 +107,7 @@ test("change", function() { expect( isOldIE ? 25 : 29 ); function step0() { - var inp = datepickerTestHelpers.initNewInput(), + var inp = testHelper.initNewInput(), dp = $( "#ui-datepicker-div" ); button = inp.siblings( "button" ); @@ -115,7 +115,7 @@ test("change", function() { image = inp.siblings( "img" ); ok( image.length === 0, "Focus - image absent" ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( dp.is( ":visible" ), "Focus - rendered on focus" ); inp.simulate( "keydown", { keyCode: $.ui.keyCode.ESCAPE } ); ok( !dp.is( ":visible" ), "Focus - hidden on exit" ); @@ -125,10 +125,10 @@ test("change", function() { function step1() { - var inp = datepickerTestHelpers.initNewInput(), + var inp = testHelper.initNewInput(), dp = $( "#ui-datepicker-div" ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( dp.is( ":visible" ), "Focus - rendered on focus" ); body.simulate( "mousedown", {} ); ok( !dp.is( ":visible" ), "Focus - hidden on external click" ); @@ -139,7 +139,7 @@ test("change", function() { } function step2() { - var inp = datepickerTestHelpers.initNewInput({ + var inp = testHelper.initNewInput({ showOn: "button", buttonText: "Popup" }), @@ -152,7 +152,7 @@ test("change", function() { ok( image.length === 0, "Button - image absent" ); equal( button.text(), "Popup", "Button - button text" ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( !dp.is( ":visible" ), "Button - not rendered on focus" ); button.click(); ok( dp.is( ":visible" ), "Button - rendered on button click" ); @@ -165,7 +165,7 @@ test("change", function() { } function step3() { - var inp = datepickerTestHelpers.initNewInput({ + var inp = testHelper.initNewInput({ showOn: "button", buttonImageOnly: true, buttonImage: "images/calendar.gif", @@ -181,7 +181,7 @@ test("change", function() { ok( /images\/calendar\.gif$/.test( image.attr( "src" ) ), "Image button - image source" ); equal( image.attr( "title" ), "Cal", "Image button - image text" ); - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( !dp.is( ":visible" ), "Image button - not rendered on focus" ); image.click(); ok( dp.is( ":visible" ), "Image button - rendered on image click" ); @@ -194,7 +194,7 @@ test("change", function() { } function step4() { - var inp = datepickerTestHelpers.initNewInput({ + var inp = testHelper.initNewInput({ showOn: "both", buttonImage: "images/calendar.gif" }), @@ -210,7 +210,7 @@ test("change", function() { // TODO: This test occasionally fails to focus in IE8 in BrowserStack if ( !isOldIE ) { - datepickerTestHelpers.onFocus( inp, function() { + testHelper.onFocus( inp, function() { ok( dp.is( ":visible" ), "Both - rendered on focus" ); body.simulate( "mousedown", {} ); ok( !dp.is( ":visible" ), "Both - hidden on external click" ); @@ -233,7 +233,7 @@ test("change", function() { test("otherMonths", function() { expect( 8 ); - var inp = datepickerTestHelpers.init("#inp"), + var inp = testHelper.init("#inp"), pop = $("#ui-datepicker-div"); inp.val("06/01/2009").datepicker("show"); equal(pop.find("tbody").text(), @@ -261,105 +261,105 @@ test("otherMonths", function() { test("defaultDate", function() { expect( 16 ); - var inp = datepickerTestHelpers.init("#inp"), + var inp = testHelper.init("#inp"), date = new Date(); inp.val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date null"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date null"); // Numeric values inp.datepicker("option", {defaultDate: -2}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date -2"); date = new Date(); inp.datepicker("option", {defaultDate: 3}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 3); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 3"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date 3"); date = new Date(); inp.datepicker("option", {defaultDate: 1 / "a"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date NaN"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date NaN"); // String offset values inp.datepicker("option", {defaultDate: "-1d"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() - 1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -1d"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date -1d"); inp.datepicker("option", {defaultDate: "+3D"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 4); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +3D"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date +3D"); inp.datepicker("option", {defaultDate: " -2 w "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(); date.setDate(date.getDate() - 14); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2 w"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date -2 w"); inp.datepicker("option", {defaultDate: "+1 W"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setDate(date.getDate() + 21); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1 W"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date +1 W"); inp.datepicker("option", {defaultDate: " -1 m "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = datepickerTestHelpers.addMonths(new Date(), -1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -1 m"); + date = testHelper.addMonths(new Date(), -1); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date -1 m"); inp.datepicker("option", {defaultDate: "+2M"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = datepickerTestHelpers.addMonths(new Date(), 2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +2M"); + date = testHelper.addMonths(new Date(), 2); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date +2M"); inp.datepicker("option", {defaultDate: "-2y"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(); date.setFullYear(date.getFullYear() - 2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date -2y"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date -2y"); inp.datepicker("option", {defaultDate: "+1 Y "}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date.setFullYear(date.getFullYear() + 3); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1 Y"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date +1 Y"); inp.datepicker("option", {defaultDate: "+1M +10d"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - date = datepickerTestHelpers.addMonths(new Date(), 1); + date = testHelper.addMonths(new Date(), 1); date.setDate(date.getDate() + 10); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date +1M +10d"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date +1M +10d"); // String date values inp.datepicker("option", {defaultDate: "07/04/2007"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(2007, 7 - 1, 4); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 07/04/2007"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date 07/04/2007"); inp.datepicker("option", {dateFormat: "yy-mm-dd", defaultDate: "2007-04-02"}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); date = new Date(2007, 4 - 1, 2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 2007-04-02"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date 2007-04-02"); // Date value date = new Date(2007, 1 - 1, 26); inp.datepicker("option", {dateFormat: "mm/dd/yy", defaultDate: date}). datepicker("hide").val("").datepicker("show"). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, "Default date 01/26/2007"); + testHelper.equalsDate(inp.datepicker("getDate"), date, "Default date 01/26/2007"); }); test("miscellaneous", function() { expect( 19 ); var curYear, longNames, shortNames, date, dp = $("#ui-datepicker-div"), - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); // Year range function genRange(start, offset) { var i = start, @@ -420,7 +420,7 @@ test("miscellaneous", function() { test("minMax", function() { expect( 23 ); var date, - inp = datepickerTestHelpers.init("#inp"), + inp = testHelper.init("#inp"), dp = $("#ui-datepicker-div"), lastYear = new Date(2007, 6 - 1, 4), nextYear = new Date(2009, 6 - 1, 4), @@ -429,45 +429,45 @@ test("minMax", function() { inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), lastYear, + testHelper.equalsDate(inp.datepicker("getDate"), lastYear, "Min/max - null, null - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), nextYear, + testHelper.equalsDate(inp.datepicker("getDate"), nextYear, "Min/max - null, null - ctrl+pgdn"); inp.datepicker("option", {minDate: minDate}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - 02/29/2008, null - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), nextYear, + testHelper.equalsDate(inp.datepicker("getDate"), nextYear, "Min/max - 02/29/2008, null - ctrl+pgdn"); inp.datepicker("option", {maxDate: maxDate}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - 02/29/2008, 12/07/2008 - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - 02/29/2008, 12/07/2008 - ctrl+pgdn"); inp.datepicker("option", {minDate: null}). datepicker("hide").val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), lastYear, + testHelper.equalsDate(inp.datepicker("getDate"), lastYear, "Min/max - null, 12/07/2008 - ctrl+pgup"); inp.val("06/04/2008").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - null, 12/07/2008 - ctrl+pgdn"); // Relative dates date = new Date(); @@ -476,31 +476,31 @@ test("minMax", function() { datepicker("hide").val("").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_UP}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, + testHelper.equalsDate(inp.datepicker("getDate"), date, "Min/max - -1w, +1 M +10 D - ctrl+pgup"); - date = datepickerTestHelpers.addMonths(new Date(), 1); + date = testHelper.addMonths(new Date(), 1); date.setDate(date.getDate() + 10); inp.val("").datepicker("show"); inp.simulate("keydown", {ctrlKey: true, keyCode: $.ui.keyCode.PAGE_DOWN}). simulate("keydown", {keyCode: $.ui.keyCode.ENTER}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date, + testHelper.equalsDate(inp.datepicker("getDate"), date, "Min/max - -1w, +1 M +10 D - ctrl+pgdn"); // With existing date - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); inp.val("06/04/2008").datepicker("option", {minDate: minDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min"); + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min"); inp.datepicker("option", {minDate: null}).val("01/04/2008").datepicker("option", {minDate: minDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); inp.datepicker("option", {minDate: null}).val("06/04/2008").datepicker("option", {maxDate: maxDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate < max"); + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate < max"); inp.datepicker("option", {maxDate: null}).val("01/04/2009").datepicker("option", {maxDate: maxDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); inp.datepicker("option", {maxDate: null}).val("01/04/2008").datepicker("option", {minDate: minDate, maxDate: maxDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Min/max - setDate < min"); inp.datepicker("option", {maxDate: null}).val("06/04/2008").datepicker("option", {minDate: minDate, maxDate: maxDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min, < max"); + testHelper.equalsDate(inp.datepicker("getDate"), new Date(2008, 6 - 1, 4), "Min/max - setDate > min, < max"); inp.datepicker("option", {maxDate: null}).val("01/04/2009").datepicker("option", {minDate: minDate, maxDate: maxDate}); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Min/max - setDate > max"); inp.datepicker("option", {yearRange: "-0:+1"}).val("01/01/" + new Date().getFullYear()); ok(dp.find(".ui-datepicker-prev").hasClass("ui-state-disabled"), "Year Range Test - previous button disabled at 1/1/minYear"); @@ -527,50 +527,50 @@ test("minMax", function() { test("setDate", function() { expect( 24 ); var inl, alt, minDate, maxDate, dateAndTimeToSet, dateAndTimeClone, - inp = datepickerTestHelpers.init("#inp"), + inp = testHelper.init("#inp"), date1 = new Date(2008, 6 - 1, 4), date2 = new Date(); ok(inp.datepicker("getDate") == null, "Set date - default"); inp.datepicker("setDate", date1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - 2008-06-04"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - 2008-06-04"); date1 = new Date(); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", +7); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - +7"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - +7"); date2.setFullYear(date2.getFullYear() + 2); inp.datepicker("setDate", "+2y"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date2, "Set date - +2y"); + testHelper.equalsDate(inp.datepicker("getDate"), date2, "Set date - +2y"); inp.datepicker("setDate", date1, date2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - two dates"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - two dates"); inp.datepicker("setDate"); ok(inp.datepicker("getDate") == null, "Set date - null"); // Relative to current date date1 = new Date(); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", "c +7"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c +7"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - c +7"); date1.setDate(date1.getDate() + 7); inp.datepicker("setDate", "c+7"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c+7"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - c+7"); date1.setDate(date1.getDate() - 21); inp.datepicker("setDate", "c -3 w"); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date - c -3 w"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date - c -3 w"); // Inline - inl = datepickerTestHelpers.init("#inl"); + inl = testHelper.init("#inl"); date1 = new Date(2008, 6 - 1, 4); date2 = new Date(); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - default"); + testHelper.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - default"); inl.datepicker("setDate", date1); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - 2008-06-04"); + testHelper.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - 2008-06-04"); date1 = new Date(); date1.setDate(date1.getDate() + 7); inl.datepicker("setDate", +7); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - +7"); + testHelper.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - +7"); date2.setFullYear(date2.getFullYear() + 2); inl.datepicker("setDate", "+2y"); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - +2y"); + testHelper.equalsDate(inl.datepicker("getDate"), date2, "Set date inline - +2y"); inl.datepicker("setDate", date1, date2); - datepickerTestHelpers.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - two dates"); + testHelper.equalsDate(inl.datepicker("getDate"), date1, "Set date inline - two dates"); inl.datepicker("setDate"); ok(inl.datepicker("getDate") == null, "Set date inline - null"); // Alternate field @@ -581,23 +581,23 @@ test("setDate", function() { equal(inp.val(), "06/04/2008", "Set date alternate - 06/04/2008"); equal(alt.val(), "2008-06-04", "Set date alternate - 2008-06-04"); // With minimum/maximum - inp = datepickerTestHelpers.init("#inp"); + inp = testHelper.init("#inp"); date1 = new Date(2008, 1 - 1, 4); date2 = new Date(2008, 6 - 1, 4); minDate = new Date(2008, 2 - 1, 29); maxDate = new Date(2008, 3 - 1, 28); inp.val("").datepicker("option", {minDate: minDate}).datepicker("setDate", date2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date2, "Set date min/max - setDate > min"); + testHelper.equalsDate(inp.datepicker("getDate"), date2, "Set date min/max - setDate > min"); inp.datepicker("setDate", date1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); inp.val("").datepicker("option", {maxDate: maxDate, minDate: null}).datepicker("setDate", date1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), date1, "Set date min/max - setDate < max"); + testHelper.equalsDate(inp.datepicker("getDate"), date1, "Set date min/max - setDate < max"); inp.datepicker("setDate", date2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); inp.val("").datepicker("option", {minDate: minDate}).datepicker("setDate", date1); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); + testHelper.equalsDate(inp.datepicker("getDate"), minDate, "Set date min/max - setDate < min"); inp.datepicker("setDate", date2); - datepickerTestHelpers.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); + testHelper.equalsDate(inp.datepicker("getDate"), maxDate, "Set date min/max - setDate > max"); dateAndTimeToSet = new Date(2008, 3 - 1, 28, 1, 11, 0); dateAndTimeClone = new Date(2008, 3 - 1, 28, 1, 11, 0); inp.datepicker("setDate", dateAndTimeToSet); @@ -606,7 +606,7 @@ test("setDate", function() { test("altField", function() { expect( 10 ); - var inp = datepickerTestHelpers.init("#inp"), + var inp = testHelper.init("#inp"), alt = $("#alt"); // No alternate field set alt.val(""); @@ -645,7 +645,7 @@ test("altField", function() { test("autoSize", function() { expect( 15 ); - var inp = datepickerTestHelpers.init("#inp"); + var inp = testHelper.init("#inp"); equal(inp.prop("size"), 20, "Auto size - default"); inp.datepicker("option", "autoSize", true); equal(inp.prop("size"), 10, "Auto size - mm/dd/yy"); @@ -683,7 +683,7 @@ test("autoSize", function() { test("daylightSaving", function() { expect( 25 ); - var inp = datepickerTestHelpers.init("#inp"), + var inp = testHelper.init("#inp"), dp = $("#ui-datepicker-div"); ok(true, "Daylight saving - " + new Date()); // Australia, Sydney - AM change, southern hemisphere @@ -789,7 +789,7 @@ test("callbacks", function() { expect( 13 ); // Before show var dp, day20, day21, - inp = datepickerTestHelpers.init("#inp", {beforeShow: beforeAll}), + inp = testHelper.init("#inp", {beforeShow: beforeAll}), inst = $.data(inp[0], "datepicker"); equal($.datepicker._get(inst, "currentText"), "Today", "Before show - initial"); inp.val("02/04/2008").datepicker("show"); @@ -799,7 +799,7 @@ test("callbacks", function() { deepEqual(beforeShowInst, inst, "Before show - inst OK"); inp.datepicker("hide").datepicker("destroy"); // Before show day - inp = datepickerTestHelpers.init("#inp", {beforeShowDay: beforeDay}); + inp = testHelper.init("#inp", {beforeShowDay: beforeDay}); dp = $("#ui-datepicker-div"); inp.val("02/04/2008").datepicker("show"); ok(beforeShowDayThis.id === inp[0].id, "Before show day - this OK"); @@ -818,7 +818,7 @@ test("callbacks", function() { test("beforeShowDay - tooltips with quotes", function() { expect( 1 ); var inp, dp; - inp = datepickerTestHelpers.init("#inp", { + inp = testHelper.init("#inp", { beforeShowDay: function() { return [ true, "", "'" ]; } @@ -833,7 +833,7 @@ test("beforeShowDay - tooltips with quotes", function() { test("localisation", function() { expect( 24 ); var dp, month, day, date, - inp = datepickerTestHelpers.init("#inp", $.datepicker.regional.fr); + inp = testHelper.init("#inp", $.datepicker.regional.fr); inp.datepicker("option", {dateFormat: "DD, d MM yy", showButtonPanel:true, changeMonth:true, changeYear:true}).val("").datepicker("show"); dp = $("#ui-datepicker-div"); equal($(".ui-datepicker-close", dp).text(), "Fermer", "Localisation - close"); @@ -900,72 +900,72 @@ test("iso8601Week", function() { test("parseDate", function() { expect( 26 ); - datepickerTestHelpers.init("#inp"); + testHelper.init("#inp"); var currentYear, gmtDate, fr, settings, zh; ok($.datepicker.parseDate("d m y", "") == null, "Parse date empty"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("d m y", "3 2 01"), + testHelper.equalsDate($.datepicker.parseDate("d m y", "3 2 01"), new Date(2001, 2 - 1, 3), "Parse date d m y"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("dd mm yy", "03 02 2001"), + testHelper.equalsDate($.datepicker.parseDate("dd mm yy", "03 02 2001"), new Date(2001, 2 - 1, 3), "Parse date dd mm yy"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("d m y", "13 12 01"), + testHelper.equalsDate($.datepicker.parseDate("d m y", "13 12 01"), new Date(2001, 12 - 1, 13), "Parse date d m y"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("dd mm yy", "13 12 2001"), + testHelper.equalsDate($.datepicker.parseDate("dd mm yy", "13 12 2001"), new Date(2001, 12 - 1, 13), "Parse date dd mm yy"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-o", "01-34"), + testHelper.equalsDate($.datepicker.parseDate("y-o", "01-34"), new Date(2001, 2 - 1, 3), "Parse date y-o"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("yy-oo", "2001-347"), + testHelper.equalsDate($.datepicker.parseDate("yy-oo", "2001-347"), new Date(2001, 12 - 1, 13), "Parse date yy-oo"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("oo yy", "348 2004"), + testHelper.equalsDate($.datepicker.parseDate("oo yy", "348 2004"), new Date(2004, 12 - 1, 13), "Parse date oo yy"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("D d M y", "Sat 3 Feb 01"), + testHelper.equalsDate($.datepicker.parseDate("D d M y", "Sat 3 Feb 01"), new Date(2001, 2 - 1, 3), "Parse date D d M y"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("d MM DD yy", "3 February Saturday 2001"), + testHelper.equalsDate($.datepicker.parseDate("d MM DD yy", "3 February Saturday 2001"), new Date(2001, 2 - 1, 3), "Parse date dd MM DD yy"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Saturday, February 3, 2001"), + testHelper.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Saturday, February 3, 2001"), new Date(2001, 2 - 1, 3), "Parse date DD, MM d, yy"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("'day' d 'of' MM (''DD''), yy", + testHelper.equalsDate($.datepicker.parseDate("'day' d 'of' MM (''DD''), yy", "day 3 of February ('Saturday'), 2001"), new Date(2001, 2 - 1, 3), "Parse date 'day' d 'of' MM (''DD''), yy"); currentYear = new Date().getFullYear(); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000) + "-02-03"), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000) + "-02-03"), new Date(currentYear, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 10) + "-02-03"), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 10) + "-02-03"), new Date(currentYear+10, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 11) + "-02-03"), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 11) + "-02-03"), new Date(currentYear-89, 2 - 1, 3), "Parse date y-m-d - default cutuff"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", "80-02-03", {shortYearCutoff: 80}), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", "80-02-03", {shortYearCutoff: 80}), new Date(2080, 2 - 1, 3), "Parse date y-m-d - cutoff 80"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", "81-02-03", {shortYearCutoff: 80}), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", "81-02-03", {shortYearCutoff: 80}), new Date(1981, 2 - 1, 3), "Parse date y-m-d - cutoff 80"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 60) + "-02-03", {shortYearCutoff: "+60"}), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 60) + "-02-03", {shortYearCutoff: "+60"}), new Date(currentYear + 60, 2 - 1, 3), "Parse date y-m-d - cutoff +60"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 61) + "-02-03", {shortYearCutoff: "+60"}), + testHelper.equalsDate($.datepicker.parseDate("y-m-d", (currentYear - 2000 + 61) + "-02-03", {shortYearCutoff: "+60"}), new Date(currentYear - 39, 2 - 1, 3), "Parse date y-m-d - cutoff +60"); gmtDate = new Date(2001, 2 - 1, 3); gmtDate.setMinutes(gmtDate.getMinutes() - gmtDate.getTimezoneOffset()); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("@", "981158400000"), gmtDate, "Parse date @"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("!", "631167552000000000"), gmtDate, "Parse date !"); + testHelper.equalsDate($.datepicker.parseDate("@", "981158400000"), gmtDate, "Parse date @"); + testHelper.equalsDate($.datepicker.parseDate("!", "631167552000000000"), gmtDate, "Parse date !"); fr = $.datepicker.regional.fr; settings = {dayNamesShort: fr.dayNamesShort, dayNames: fr.dayNames, monthNamesShort: fr.monthNamesShort, monthNames: fr.monthNames}; - datepickerTestHelpers.equalsDate($.datepicker.parseDate("D d M y", "Lun. 9 avr. 01", settings), + testHelper.equalsDate($.datepicker.parseDate("D d M y", "Lun. 9 avr. 01", settings), new Date(2001, 4 - 1, 9), "Parse date D M y with settings"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("d MM DD yy", "9 Avril Lundi 2001", settings), + testHelper.equalsDate($.datepicker.parseDate("d MM DD yy", "9 Avril Lundi 2001", settings), new Date(2001, 4 - 1, 9), "Parse date d MM DD yy with settings"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Lundi, Avril 9, 2001", settings), + testHelper.equalsDate($.datepicker.parseDate("DD, MM d, yy", "Lundi, Avril 9, 2001", settings), new Date(2001, 4 - 1, 9), "Parse date DD, MM d, yy with settings"); - datepickerTestHelpers.equalsDate($.datepicker.parseDate("'jour' d 'de' MM (''DD''), yy", "jour 9 de Avril ('Lundi'), 2001", settings), + testHelper.equalsDate($.datepicker.parseDate("'jour' d 'de' MM (''DD''), yy", "jour 9 de Avril ('Lundi'), 2001", settings), new Date(2001, 4 - 1, 9), "Parse date 'jour' d 'de' MM (''DD''), yy with settings"); zh = $.datepicker.regional["zh-CN"]; - datepickerTestHelpers.equalsDate($.datepicker.parseDate("yy M d", "2011 十一月 22", zh), + testHelper.equalsDate($.datepicker.parseDate("yy M d", "2011 十一月 22", zh), new Date(2011, 11 - 1, 22), "Parse date yy M d with zh-CN"); }); test("parseDateErrors", function() { expect( 18 ); - datepickerTestHelpers.init("#inp"); + testHelper.init("#inp"); var fr, settings; function expectError(expr, value, error) { try { @@ -1040,7 +1040,7 @@ test("Ticket #7244: date parser does not fail when too many numbers are passed i test("formatDate", function() { expect( 16 ); - datepickerTestHelpers.init("#inp"); + testHelper.init("#inp"); var gmtDate, fr, settings; equal($.datepicker.formatDate("d m y", new Date(2001, 2 - 1, 3)), "3 2 01", "Format date d m y"); @@ -1093,7 +1093,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler var inp, dp; - inp = datepickerTestHelpers.init( "#inp", { + inp = testHelper.init( "#inp", { beforeShow: function() { } }); @@ -1102,7 +1102,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler equal( dp.css( "display" ), "block", "beforeShow returns nothing" ); inp.datepicker( "hide" ).datepicker( "destroy" ); - inp = datepickerTestHelpers.init( "#inp", { + inp = testHelper.init( "#inp", { beforeShow: function() { return true; } @@ -1113,7 +1113,7 @@ test( "Ticket 7602: Stop datepicker from appearing with beforeShow event handler inp.datepicker( "hide" ); inp.datepicker( "destroy" ); - inp = datepickerTestHelpers.init( "#inp", { + inp = testHelper.init( "#inp", { beforeShow: function() { return false; } diff --git a/tests/unit/datepicker/datepicker_test_helpers.js b/tests/unit/datepicker/datepicker_test_helpers.js index 40dc934105a..4cd9b48ffa8 100644 --- a/tests/unit/datepicker/datepicker_test_helpers.js +++ b/tests/unit/datepicker/datepicker_test_helpers.js @@ -1,15 +1,17 @@ define( [ + "jquery", "lib/helper", "ui/datepicker" -], function( testHelpers ) { +], function( $, helper ) { -var datepickerTestHelpers = { +return $.extend( helper, { addMonths: function(date, offset) { var maxDay = 32 - new Date(date.getFullYear(), date.getMonth() + offset, 32).getDate(); date.setDate(Math.min(date.getDate(), maxDay)); date.setMonth(date.getMonth() + offset); return date; }, + equalsDate: function(d1, d2, message) { if (!d1 || !d2) { ok(false, message + " - missing date"); @@ -19,18 +21,18 @@ var datepickerTestHelpers = { d2 = new Date(d2.getFullYear(), d2.getMonth(), d2.getDate()); equal(d1.toString(), d2.toString(), message); }, + init: function( id, options ) { $.datepicker.setDefaults( $.datepicker.regional[ "" ] ); return $( id ).datepicker( $.extend( { showAnim: "" }, options || {} ) ); }, + initNewInput: function( options ) { var id = $( "" ).appendTo( "#qunit-fixture" ); - return datepickerTestHelpers.init( id, options ); + return this.init( id, options ); }, - onFocus: testHelpers.onFocus, - PROP_NAME: "datepicker" -}; -return datepickerTestHelpers; + PROP_NAME: "datepicker" +} ); } ); diff --git a/tests/unit/dialog/dialog_events.js b/tests/unit/dialog/dialog_events.js index a6e4c0501b4..cc5bef8fa80 100644 --- a/tests/unit/dialog/dialog_events.js +++ b/tests/unit/dialog/dialog_events.js @@ -2,7 +2,7 @@ define( [ "jquery", "./dialog_test_helpers", "ui/dialog" -], function( $, dialogTestHelpers ) { +], function( $, testHelper ) { module("dialog: events"); @@ -104,7 +104,7 @@ test("dragStart", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); @@ -132,7 +132,7 @@ test("drag", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); @@ -156,7 +156,7 @@ test("dragStop", function() { }); handle = $(".ui-dialog-titlebar", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); @@ -184,7 +184,7 @@ test("resizeStart", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); @@ -216,7 +216,7 @@ test("resize", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); @@ -244,7 +244,7 @@ test("resizeStop", function() { }); handle = $(".ui-resizable-se", element.dialog("widget")); - dialogTestHelpers.drag(element, handle, 50, 50); + testHelper.drag(element, handle, 50, 50); element.remove(); }); diff --git a/tests/unit/dialog/dialog_options.js b/tests/unit/dialog/dialog_options.js index e4ff6ac7202..1b9af7a095b 100644 --- a/tests/unit/dialog/dialog_options.js +++ b/tests/unit/dialog/dialog_options.js @@ -4,7 +4,7 @@ define( [ "ui/dialog", "ui/effect-blind", "ui/effect-explode" -], function( $, dialogTestHelpers ) { +], function( $, testHelper ) { module("dialog: options"); @@ -231,15 +231,15 @@ test("draggable", function() { var element = $("
").dialog({ draggable: false }); - dialogTestHelpers.testDrag(element, 50, -50, 0, 0); + testHelper.testDrag(element, 50, -50, 0, 0); element.dialog("option", "draggable", true); - dialogTestHelpers.testDrag(element, 50, -50, 50, -50); + testHelper.testDrag(element, 50, -50, 50, -50); element.remove(); element = $("
").dialog({ draggable: true }); - dialogTestHelpers.testDrag(element, 50, -50, 50, -50); + testHelper.testDrag(element, 50, -50, 50, -50); element.dialog("option", "draggable", false); - dialogTestHelpers.testDrag(element, 50, -50, 0, 0); + testHelper.testDrag(element, 50, -50, 0, 0); element.remove(); }); @@ -269,17 +269,17 @@ test("maxHeight", function( assert ) { expect(3); var element = $("
").dialog({ maxHeight: 200 }); - dialogTestHelpers.drag(element, ".ui-resizable-s", 1000, 1000); + testHelper.drag(element, ".ui-resizable-s", 1000, 1000); assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }); - dialogTestHelpers.drag(element, ".ui-resizable-n", -1000, -1000); + testHelper.drag(element, ".ui-resizable-n", -1000, -1000); assert.close(element.dialog("widget").height(), 200, 1, "maxHeight"); element.remove(); element = $("
").dialog({ maxHeight: 200 }).dialog("option", "maxHeight", 300); - dialogTestHelpers.drag(element, ".ui-resizable-s", 1000, 1000); + testHelper.drag(element, ".ui-resizable-s", 1000, 1000); assert.close(element.dialog("widget").height(), 300, 1, "maxHeight"); element.remove(); }); @@ -288,17 +288,17 @@ test("maxWidth", function( assert ) { expect(3); var element = $("
").dialog({ maxWidth: 200 }); - dialogTestHelpers.drag(element, ".ui-resizable-e", 1000, 1000); + testHelper.drag(element, ".ui-resizable-e", 1000, 1000); assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }); - dialogTestHelpers.drag(element, ".ui-resizable-w", -1000, -1000); + testHelper.drag(element, ".ui-resizable-w", -1000, -1000); assert.close(element.dialog("widget").width(), 200, 1, "maxWidth"); element.remove(); element = $("
").dialog({ maxWidth: 200 }).dialog("option", "maxWidth", 300); - dialogTestHelpers.drag(element, ".ui-resizable-w", -1000, -1000); + testHelper.drag(element, ".ui-resizable-w", -1000, -1000); assert.close(element.dialog("widget").width(), 300, 1, "maxWidth"); element.remove(); }); @@ -307,17 +307,17 @@ test("minHeight", function( assert ) { expect(3); var element = $("
").dialog({ minHeight: 10 }); - dialogTestHelpers.drag(element, ".ui-resizable-s", -1000, -1000); + testHelper.drag(element, ".ui-resizable-s", -1000, -1000); assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }); - dialogTestHelpers.drag(element, ".ui-resizable-n", 1000, 1000); + testHelper.drag(element, ".ui-resizable-n", 1000, 1000); assert.close(element.dialog("widget").height(), 10, 1, "minHeight"); element.remove(); element = $("
").dialog({ minHeight: 10 }).dialog("option", "minHeight", 30); - dialogTestHelpers.drag(element, ".ui-resizable-n", 1000, 1000); + testHelper.drag(element, ".ui-resizable-n", 1000, 1000); assert.close(element.dialog("widget").height(), 30, 1, "minHeight"); element.remove(); }); @@ -326,17 +326,17 @@ test("minWidth", function( assert ) { expect(3); var element = $("
").dialog({ minWidth: 10 }); - dialogTestHelpers.drag(element, ".ui-resizable-e", -1000, -1000); + testHelper.drag(element, ".ui-resizable-e", -1000, -1000); assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 10 }); - dialogTestHelpers.drag(element, ".ui-resizable-w", 1000, 1000); + testHelper.drag(element, ".ui-resizable-w", 1000, 1000); assert.close(element.dialog("widget").width(), 10, 1, "minWidth"); element.remove(); element = $("
").dialog({ minWidth: 30 }).dialog("option", "minWidth", 30); - dialogTestHelpers.drag(element, ".ui-resizable-w", 1000, 1000); + testHelper.drag(element, ".ui-resizable-w", 1000, 1000); assert.close(element.dialog("widget").width(), 30, 1, "minWidth"); element.remove(); }); @@ -424,15 +424,15 @@ test("resizable", function() { expect(4); var element = $("
").dialog(); - dialogTestHelpers.shouldResize(element, 50, 50, "[default]"); + testHelper.shouldResize(element, 50, 50, "[default]"); element.dialog("option", "resizable", false); - dialogTestHelpers.shouldResize(element, 0, 0, "disabled after init"); + testHelper.shouldResize(element, 0, 0, "disabled after init"); element.remove(); element = $("
").dialog({ resizable: false }); - dialogTestHelpers.shouldResize(element, 0, 0, "disabled in init options"); + testHelper.shouldResize(element, 0, 0, "disabled in init options"); element.dialog("option", "resizable", true); - dialogTestHelpers.shouldResize(element, 50, 50, "enabled after init"); + testHelper.shouldResize(element, 50, 50, "enabled after init"); element.remove(); }); @@ -497,18 +497,18 @@ test("#4826: setting resizable false toggles resizable on dialog", function() { var i, element = $("
").dialog({ resizable: false }); - dialogTestHelpers.shouldResize(element, 0, 0, "[default]"); + testHelper.shouldResize(element, 0, 0, "[default]"); for (i=0; i<2; i++) { element.dialog("close").dialog("open"); - dialogTestHelpers.shouldResize(element, 0, 0, "initialized with resizable false toggle ("+ (i+1) +")"); + testHelper.shouldResize(element, 0, 0, "initialized with resizable false toggle ("+ (i+1) +")"); } element.remove(); element = $("
").dialog({ resizable: true }); - dialogTestHelpers.shouldResize(element, 50, 50, "[default]"); + testHelper.shouldResize(element, 50, 50, "[default]"); for (i=0; i<2; i++) { element.dialog("close").dialog("option", "resizable", false).dialog("open"); - dialogTestHelpers.shouldResize(element, 0, 0, "set option resizable false toggle ("+ (i+1) +")"); + testHelper.shouldResize(element, 0, 0, "set option resizable false toggle ("+ (i+1) +")"); } element.remove(); diff --git a/tests/unit/dialog/dialog_test_helpers.js b/tests/unit/dialog/dialog_test_helpers.js index f11c77cded4..f84d1d624b6 100644 --- a/tests/unit/dialog/dialog_test_helpers.js +++ b/tests/unit/dialog/dialog_test_helpers.js @@ -1,6 +1,10 @@ -define( function() { +define( [ + "jquery", + "lib/helper", + "ui/dialog" +], function( $, helper ) { -var dialogTestHelpers = { +return $.extend( helper, { drag: function(element, handle, dx, dy) { var d = element.dialog("widget"); //this mouseover is to work around a limitation in resizable @@ -16,7 +20,7 @@ var dialogTestHelpers = { handle = $(".ui-dialog-titlebar", d), offsetBefore = d.offset(); - dialogTestHelpers.drag(element, handle, dx, dy); + this.drag(element, handle, dx, dy); offsetAfter = d.offset(); @@ -36,7 +40,7 @@ var dialogTestHelpers = { heightBefore = element.height(), widthBefore = element.width(); - dialogTestHelpers.drag(element, handle, 50, 50); + this.drag(element, handle, 50, 50); heightAfter = element.height(); widthAfter = element.width(); @@ -46,8 +50,6 @@ var dialogTestHelpers = { expected = { width: widthBefore + dw, height: heightBefore + dh }; deepEqual(actual, expected, "resized[" + 50 + ", " + 50 + "] " + msg); } -}; - -return dialogTestHelpers; +} ); } ); diff --git a/tests/unit/draggable/draggable_core.js b/tests/unit/draggable/draggable_core.js index d484b776d37..9df8f4da701 100644 --- a/tests/unit/draggable/draggable_core.js +++ b/tests/unit/draggable/draggable_core.js @@ -1,11 +1,10 @@ define( [ "jquery", - "lib/helper", "./draggable_test_helpers", "ui/draggable", "ui/droppable", "ui/resizable" -], function( $, testHelpers, draggableTestHelpers ) { +], function( $, testHelper ) { module( "draggable: core" ); @@ -54,12 +53,12 @@ test( "element types", function( assert ) { test( "No options, relative", function() { expect( 2 ); - draggableTestHelpers.shouldMove( $( "#draggable1" ).draggable(), "no options, relative" ); + testHelper.shouldMove( $( "#draggable1" ).draggable(), "no options, relative" ); }); test( "No options, absolute", function() { expect( 2 ); - draggableTestHelpers.shouldMove( $( "#draggable2" ).draggable(), "no options, absolute" ); + testHelper.shouldMove( $( "#draggable2" ).draggable(), "no options, absolute" ); }); test( "resizable handle with complex markup (#8756 / #8757)", function() { @@ -102,7 +101,7 @@ test( "#8269: Removing draggable element on drop", function() { }); // Support: Opera 12.10, Safari 5.1, jQuery <1.8 - if ( draggableTestHelpers.unreliableContains ) { + if ( testHelper.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -128,7 +127,7 @@ test( "Stray mousemove after mousedown still drags", function() { $( document ).simulate( "mousemove", { button: -1 }); }); - draggableTestHelpers.shouldMove( element, "element is draggable" ); + testHelper.shouldMove( element, "element is draggable" ); }); test( "#6258: not following mouse when scrolled and using overflow-y: scroll", function() { @@ -148,7 +147,7 @@ test( "#6258: not following mouse when scrolled and using overflow-y: scroll", f oldOverflowY = $( "html" ).css( "overflow-y" ), oldOverflowX = $( "html" ).css( "overflow-x" ); - testHelpers.forceScrollableWindow(); + testHelper.forceScrollableWindow(); $( "html" ) .css( "overflow-y", "scroll" ) @@ -174,7 +173,7 @@ test( "#9315: jumps down with offset of scrollbar", function() { } }); - testHelpers.forceScrollableWindow(); + testHelper.forceScrollableWindow(); $( "html" ).scrollTop( 300 ).scrollLeft( 300 ); @@ -208,7 +207,7 @@ test( "scroll offset with fixed ancestors", function() { } }); - testHelpers.forceScrollableWindow(); + testHelper.forceScrollableWindow(); $( "#wrapper" ).css( "position", "fixed" ); $( "#wrapper2" ).css( "position", "absolute" ); @@ -279,8 +278,8 @@ test( "#5727: draggable from iframe", function() { equal( draggable1.closest( iframeBody ).length, 1 ); // TODO: fix draggable within an IFRAME to fire events on the element properly - // and these draggableTestHelpers.shouldMove relies on events for testing - //draggableTestHelpers.shouldMove( draggable1, "draggable from an iframe" ); + // and these testHelper.shouldMove relies on events for testing + //testHelper.shouldMove( draggable1, "draggable from an iframe" ); }); test( "#8399: A draggable should become the active element after you are finished interacting with it, but not before.", function() { @@ -292,7 +291,7 @@ test( "#8399: A draggable should become the active element after you are finishe notStrictEqual( document.activeElement, element.get( 0 ), "moving a draggable anchor did not make it the active element" ); }); - draggableTestHelpers.move( element, 50, 50 ); + testHelper.move( element, 50, 50 ); strictEqual( document.activeElement, element.get( 0 ), "finishing moving a draggable anchor made it the active element" ); }); @@ -303,16 +302,16 @@ asyncTest( "blur behavior", function() { var element = $( "#draggable1" ).draggable(), focusElement = $( "
" ).appendTo( element ); - testHelpers.onFocus( focusElement, function() { + testHelper.onFocus( focusElement, function() { strictEqual( document.activeElement, focusElement.get( 0 ), "test element is focused before mousing down on a draggable" ); - draggableTestHelpers.move( focusElement, 1, 1 ); + testHelper.move( focusElement, 1, 1 ); // http://bugs.jqueryui.com/ticket/10527 // Draggable: Can't select option in modal dialog (IE8) strictEqual( document.activeElement, focusElement.get( 0 ), "test element is focused after mousing down on itself" ); - draggableTestHelpers.move( element, 50, 50 ); + testHelper.move( element, 50, 50 ); // http://bugs.jqueryui.com/ticket/4261 // active element should blur when mousing down on a draggable @@ -364,7 +363,7 @@ test( "setting right/bottom css shouldn't cause resize", function( assert ) { element.draggable(); - draggableTestHelpers.move( element, -50, -50 ); + testHelper.move( element, -50, -50 ); finalOffset = element.offset(); finalOffset.left += 50; diff --git a/tests/unit/draggable/draggable_methods.js b/tests/unit/draggable/draggable_methods.js index 44e5feb433c..74c5b67e80b 100644 --- a/tests/unit/draggable/draggable_methods.js +++ b/tests/unit/draggable/draggable_methods.js @@ -2,7 +2,7 @@ define( [ "jquery", "./draggable_test_helpers", "ui/draggable" -], function( $, draggableTestHelpers ) { +], function( $, testHelper ) { var element; @@ -55,19 +55,19 @@ test( "enable", function() { expect( 11 ); element.draggable({ disabled: true }); - draggableTestHelpers.shouldNotDrag( element, ".draggable({ disabled: true })" ); + testHelper.shouldNotDrag( element, ".draggable({ disabled: true })" ); element.draggable("enable"); - draggableTestHelpers.shouldMove( element, ".draggable('enable')" ); + testHelper.shouldMove( element, ".draggable('enable')" ); equal( element.draggable( "option", "disabled" ), false, "disabled option getter" ); element.draggable("destroy"); element.draggable({ disabled: true }); - draggableTestHelpers.shouldNotDrag( element, ".draggable({ disabled: true })" ); + testHelper.shouldNotDrag( element, ".draggable({ disabled: true })" ); element.draggable( "option", "disabled", false ); equal(element.draggable( "option", "disabled" ), false, "disabled option setter" ); - draggableTestHelpers.shouldMove( element, ".draggable('option', 'disabled', false)" ); + testHelper.shouldMove( element, ".draggable('option', 'disabled', false)" ); var expected = element.draggable(), actual = expected.draggable("enable"); @@ -78,19 +78,19 @@ test( "disable", function( assert ) { expect( 14 ); element = $( "#draggable2" ).draggable({ disabled: false }); - draggableTestHelpers.shouldMove( element, ".draggable({ disabled: false })" ); + testHelper.shouldMove( element, ".draggable({ disabled: false })" ); element.draggable( "disable" ); - draggableTestHelpers.shouldNotDrag( element, ".draggable('disable')" ); + testHelper.shouldNotDrag( element, ".draggable('disable')" ); equal( element.draggable( "option", "disabled" ), true, "disabled option getter" ); element.draggable( "destroy" ); element.draggable({ disabled: false }); - draggableTestHelpers.shouldMove( element, ".draggable({ disabled: false })" ); + testHelper.shouldMove( element, ".draggable({ disabled: false })" ); element.draggable( "option", "disabled", true ); equal( element.draggable( "option", "disabled" ), true, "disabled option setter" ); - draggableTestHelpers.shouldNotDrag( element, ".draggable('option', 'disabled', true)" ); + testHelper.shouldNotDrag( element, ".draggable('option', 'disabled', true)" ); assert.lacksClasses( element.draggable( "widget" ), "ui-state-disabled" ); ok( !element.draggable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); diff --git a/tests/unit/draggable/draggable_options.js b/tests/unit/draggable/draggable_options.js index a67854e9687..5368103b789 100644 --- a/tests/unit/draggable/draggable_options.js +++ b/tests/unit/draggable/draggable_options.js @@ -4,16 +4,16 @@ define( [ "ui/draggable", "ui/droppable", "ui/sortable" -], function( $, draggableTestHelpers ) { +], function( $, testHelper ) { // TODO: This doesn't actually test whether append happened, possibly remove test( "{ appendTo: 'parent' }, default, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: "parent" }); - draggableTestHelpers.shouldMove( element, "absolute appendTo: parent" ); + testHelper.shouldMove( element, "absolute appendTo: parent" ); element = $( "#draggable1" ).draggable({ appendTo: "parent" }); - draggableTestHelpers.shouldMove( element, "relative appendTo: parent" ); + testHelper.shouldMove( element, "relative appendTo: parent" ); }); // TODO: This doesn't actually test whether append happened, possibly remove @@ -21,20 +21,20 @@ test( "{ appendTo: Element }, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] }); - draggableTestHelpers.shouldMove( element, "absolute appendTo: Element" ); + testHelper.shouldMove( element, "absolute appendTo: Element" ); element = $( "#draggable1" ).draggable({ appendTo: $( "#draggable2" ).parent()[ 0 ] }); - draggableTestHelpers.shouldMove( element, "relative appendTo: Element" ); + testHelper.shouldMove( element, "relative appendTo: Element" ); }); // TODO: This doesn't actually test whether append happened, possibly remove test( "{ appendTo: Selector }, no clone", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ appendTo: "#main" }); - draggableTestHelpers.shouldMove( element, "absolute appendTo: Selector" ); + testHelper.shouldMove( element, "absolute appendTo: Selector" ); element = $( "#draggable1" ).draggable({ appendTo: "#main" }); - draggableTestHelpers.shouldMove( element, "relative appendTo: Selector" ); + testHelper.shouldMove( element, "relative appendTo: Selector" ); }); test( "{ appendTo: 'parent' }, default", function() { @@ -42,11 +42,11 @@ test( "{ appendTo: 'parent' }, default", function() { var element = $( "#draggable1" ).draggable(); - draggableTestHelpers.trackAppendedParent( element ); + testHelper.trackAppendedParent( element ); equal( element.draggable( "option", "appendTo" ), "parent" ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $( "#main" )[ 0 ] ); }); @@ -56,9 +56,9 @@ test( "{ appendTo: Element }", function() { var appendTo = $( "#draggable2" ).parent()[ 0 ], element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - draggableTestHelpers.trackAppendedParent( element ); + testHelper.trackAppendedParent( element ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), appendTo ); }); @@ -68,9 +68,9 @@ test( "{ appendTo: jQuery }", function() { var appendTo = $( "#draggable2" ).parent(), element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - draggableTestHelpers.trackAppendedParent( element ); + testHelper.trackAppendedParent( element ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), appendTo[ 0 ] ); }); @@ -80,9 +80,9 @@ test( "{ appendTo: Selector }", function() { var appendTo = "#main", element = $( "#draggable1" ).draggable({ appendTo: appendTo }); - draggableTestHelpers.trackAppendedParent( element ); + testHelper.trackAppendedParent( element ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $(appendTo)[ 0 ] ); }); @@ -91,34 +91,34 @@ test( "appendTo, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable({ helper: "clone" }); - draggableTestHelpers.trackAppendedParent( element ); + testHelper.trackAppendedParent( element ); // Move and make sure element was appended to fixture - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_parent" ), $( "#main" )[ 0 ] ); // Move and make sure element was appended to main element.draggable( "option", "appendTo", $( "#qunit-fixture" ) ); - draggableTestHelpers.move( element, 2, 2 ); + testHelper.move( element, 2, 2 ); equal( element.data( "last_dragged_parent" ), $( "#qunit-fixture" )[ 0 ] ); }); test( "{ axis: false }, default", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: false }); - draggableTestHelpers.shouldMove( element, "axis: false" ); + testHelper.shouldMove( element, "axis: false" ); }); test( "{ axis: 'x' }", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: "x" }); - draggableTestHelpers.testDrag( element, element, 50, 50, 50, 0, "axis: x" ); + testHelper.testDrag( element, element, 50, 50, 50, 0, "axis: x" ); }); test( "{ axis: 'y' }", function() { expect( 2 ); var element = $( "#draggable2" ).draggable({ axis: "y" }); - draggableTestHelpers.testDrag( element, element, 50, 50, 0, 50, "axis: y" ); + testHelper.testDrag( element, element, 50, 50, 0, 50, "axis: y" ); }); test( "{ axis: ? }, unexpected", function() { @@ -136,7 +136,7 @@ test( "{ axis: ? }, unexpected", function() { $.each(unexpected, function(key, val) { element = $( "#draggable2" ).draggable({ axis: val }); - draggableTestHelpers.shouldMove( element, "axis: " + key ); + testHelper.shouldMove( element, "axis: " + key ); element.draggable( "destroy" ); }); }); @@ -147,15 +147,15 @@ test( "axis, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable({ axis: false }); // Any Direction - draggableTestHelpers.shouldMove( element, "axis: default" ); + testHelper.shouldMove( element, "axis: default" ); // Only horizontal element.draggable( "option", "axis", "x" ); - draggableTestHelpers.testDrag( element, element, 50, 50, 50, 0, "axis: x as option" ); + testHelper.testDrag( element, element, 50, 50, 50, 0, "axis: x as option" ); // Vertical only element.draggable( "option", "axis", "y" ); - draggableTestHelpers.testDrag( element, element, 50, 50, 0, 50, "axis: y as option" ); + testHelper.testDrag( element, element, 50, 50, 0, 50, "axis: y as option" ); }); @@ -165,12 +165,12 @@ test( "{ cancel: 'input,textarea,button,select,option' }, default", function() { $( "
" ).appendTo( "#qunit-fixture" ); var element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" }); - draggableTestHelpers.shouldMove( element, "cancel: default, element dragged" ); + testHelper.shouldMove( element, "cancel: default, element dragged" ); element.draggable( "destroy" ); element = $( "#draggable-option-cancel-default" ).draggable({ cancel: "input,textarea,button,select,option" }); - draggableTestHelpers.shouldNotDrag( element, "cancel: default, input dragged", "#draggable-option-cancel-default input" ); + testHelper.shouldNotDrag( element, "cancel: default, input dragged", "#draggable-option-cancel-default input" ); element.draggable( "destroy" ); }); @@ -178,12 +178,12 @@ test( "{ cancel: 'span' }", function() { expect( 4 ); var element = $( "#draggable2" ).draggable(); - draggableTestHelpers.shouldMove( element, "cancel: default, span dragged", "#draggable2 span" ); + testHelper.shouldMove( element, "cancel: default, span dragged", "#draggable2 span" ); element.draggable( "destroy" ); element = $( "#draggable2" ).draggable({ cancel: "span" }); - draggableTestHelpers.shouldNotDrag( element, "cancel: span, span dragged", "#draggable2 span" ); + testHelper.shouldNotDrag( element, "cancel: span, span dragged", "#draggable2 span" ); }); test( "{ cancel: ? }, unexpected", function() { @@ -201,7 +201,7 @@ test( "{ cancel: ? }, unexpected", function() { $.each( unexpected, function( key, val ) { element = $( "#draggable2" ).draggable({ cancel: val }); - draggableTestHelpers.shouldMove( element, "cancel: " + key ); + testHelper.shouldMove( element, "cancel: " + key ); element.draggable( "destroy" ); }); }); @@ -219,15 +219,15 @@ test( "{ cancel: Selectors }, matching parent selector", function() { $( "#wrapping a" ).append( element ); - draggableTestHelpers.shouldMove( element, "drag span child", "#draggable2 span" ); - draggableTestHelpers.shouldNotDrag( $( "#draggable2 span a" ), "drag span a" ); - draggableTestHelpers.shouldNotDrag( $( "#wrapping a" ), "drag wrapping a" ); + testHelper.shouldMove( element, "drag span child", "#draggable2 span" ); + testHelper.shouldNotDrag( $( "#draggable2 span a" ), "drag span a" ); + testHelper.shouldNotDrag( $( "#wrapping a" ), "drag wrapping a" ); $( "#draggable2" ).draggable( "option", "cancel", "span > a" ); $( "#draggable2" ).find( "a" ).append( "" ); - draggableTestHelpers.shouldMove( element, "drag span child", $( "#draggable2 span a" ).last() ); - draggableTestHelpers.shouldNotDrag( $( "#draggable2 span a" ).first(), "drag span a first child" ); + testHelper.shouldMove( element, "drag span child", $( "#draggable2 span a" ).last() ); + testHelper.shouldNotDrag( $( "#draggable2 span a" ).first(), "drag span a first child" ); }); */ @@ -239,13 +239,13 @@ test( "cancelement, default, switching after initialization", function() { var input = $( "#draggable-option-cancel-default input" ), element = $( "#draggable-option-cancel-default" ).draggable(); - draggableTestHelpers.shouldNotDrag( element, "cancel: default, input dragged", input ); + testHelper.shouldNotDrag( element, "cancel: default, input dragged", input ); element.draggable( "option", "cancel", "textarea" ); - draggableTestHelpers.shouldMove( element, "cancel: textarea, input dragged", input ); + testHelper.shouldMove( element, "cancel: textarea, input dragged", input ); element.draggable( "option", "cancel", "input" ); - draggableTestHelpers.shouldNotDrag( element, "cancel: input, input dragged", input ); + testHelper.shouldNotDrag( element, "cancel: input, input dragged", input ); }); test( "connectToSortable, dragging out of a sortable", function() { @@ -440,8 +440,8 @@ test( "{ containment: Element }", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), - top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) + left: po.left + testHelper.border( p, "left" ) + testHelper.margin( element, "left" ), + top: po.top + testHelper.border( p, "top" ) + testHelper.margin( element, "top" ) }; element.simulate( "drag", { @@ -460,8 +460,8 @@ test( "{ containment: Selector }", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), - top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) + left: po.left + testHelper.border( p, "left" ) + testHelper.margin( element, "left" ), + top: po.top + testHelper.border( p, "top" ) + testHelper.margin( element, "top" ) }; element.simulate( "drag", { @@ -480,7 +480,7 @@ test( "{ containment: [x1, y1, x2, y2] }", function() { element.draggable( "option", "containment", [ eo.left, eo.top, eo.left + element.width() + 5, eo.top + element.height() + 5 ] ); - draggableTestHelpers.testDrag( element, element, -100, -100, 0, 0, "containment: [x1, y1, x2, y2]" ); + testHelper.testDrag( element, element, -100, -100, 0, 0, "containment: [x1, y1, x2, y2]" ); }); test( "{ containment: 'parent' }, relative", function() { @@ -491,8 +491,8 @@ test( "{ containment: 'parent' }, relative", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), - top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) + left: po.left + testHelper.border( p, "left" ) + testHelper.margin( element, "left" ), + top: po.top + testHelper.border( p, "top" ) + testHelper.margin( element, "top" ) }; element.simulate( "drag", { @@ -511,8 +511,8 @@ test( "{ containment: 'parent' }, absolute", function() { p = element.parent(), po = p.offset(), expected = { - left: po.left + draggableTestHelpers.border( p, "left" ) + draggableTestHelpers.margin( element, "left" ), - top: po.top + draggableTestHelpers.border( p, "top" ) + draggableTestHelpers.margin( element, "top" ) + left: po.left + testHelper.border( p, "left" ) + testHelper.margin( element, "left" ), + top: po.top + testHelper.border( p, "top" ) + testHelper.margin( element, "top" ) }; element.simulate( "drag", { @@ -535,8 +535,8 @@ test( "containment, account for border", function( assert ) { }), parentBottom = parent.offset().top + parent.outerHeight(), parentRight = parent.offset().left + parent.outerWidth(), - parentBorderBottom = draggableTestHelpers.border( parent, "bottom" ), - parentBorderRight = draggableTestHelpers.border( parent, "right" ); + parentBorderBottom = testHelper.border( parent, "bottom" ), + parentBorderRight = testHelper.border( parent, "right" ); el.css({ height: "5px", @@ -591,16 +591,16 @@ test( "containment, default, switching after initialization", function() { po = element.parent().offset(), containment = [ po.left - 100, po.top - 100, po.left + 500, po.top + 500 ]; - draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: default" ); + testHelper.testDrag( element, element, -100, -100, -100, -100, "containment: default" ); element.draggable( "option", "containment", "parent" ).css({ top: 0, left: 0 }); - draggableTestHelpers.testDrag( element, element, -100, -100, 0, 0, "containment: parent as option" ); + testHelper.testDrag( element, element, -100, -100, 0, 0, "containment: parent as option" ); element.draggable( "option", "containment", containment ).css({ top: 0, left: 0 }); - draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: array as option" ); + testHelper.testDrag( element, element, -100, -100, -100, -100, "containment: array as option" ); element.draggable( "option", "containment", false ); - draggableTestHelpers.testDrag( element, element, -100, -100, -100, -100, "containment: false as option" ); + testHelper.testDrag( element, element, -100, -100, -100, -100, "containment: false as option" ); }); test( "{ cursor: 'auto' }, default", function() { @@ -678,7 +678,7 @@ test( "#6889: Cursor doesn't revert to pre-dragging state after revert action wh }), expected = getCursor(); - if ( draggableTestHelpers.unreliableContains ) { + if ( testHelper.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -694,17 +694,17 @@ test( "cursor, default, switching after initialization", function() { var element = $( "#draggable1" ).draggable(); - draggableTestHelpers.trackMouseCss( element ); + testHelper.trackMouseCss( element ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "auto" ); element.draggable( "option", "cursor", "move" ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "move" ); element.draggable( "option", "cursor", "ns-resize" ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.data( "last_dragged_cursor" ), "ns-resize" ); }); @@ -731,11 +731,11 @@ test( "cursorAt", function() { equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" ); equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" ); } else if ( testData.cursorAt.right ) { - equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); - equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); + equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - testHelper.unreliableOffset, testName + " " + position + " left" ); + equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - testHelper.unreliableOffset, testName + " " + position + " top" ); } else { - equal( event.clientX - ui.offset.left, testData.x + draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); - equal( event.clientY - ui.offset.top, testData.y + draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); + equal( event.clientX - ui.offset.left, testData.x + testHelper.unreliableOffset, testName + " " + position + " left" ); + equal( event.clientY - ui.offset.top, testData.y + testHelper.unreliableOffset, testName + " " + position + " top" ); } } }); @@ -773,11 +773,11 @@ test( "cursorAt, switching after initialization", function() { equal( ui.position.left - ui.originalPosition.left, deltaX, testName + " " + position + " left" ); equal( ui.position.top - ui.originalPosition.top, deltaY, testName + " " + position + " top" ); } else if ( testData.cursorAt.right ) { - equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); - equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); + equal( ui.helper.width() - ( event.clientX - ui.offset.left ), testData.x - testHelper.unreliableOffset, testName + " " + position + " left" ); + equal( ui.helper.height() - ( event.clientY - ui.offset.top ), testData.y - testHelper.unreliableOffset, testName + " " + position + " top" ); } else { - equal( event.clientX - ui.offset.left, testData.x + draggableTestHelpers.unreliableOffset, testName + " " + position + " left" ); - equal( event.clientY - ui.offset.top, testData.y + draggableTestHelpers.unreliableOffset, testName + " " + position + " top" ); + equal( event.clientX - ui.offset.left, testData.x + testHelper.unreliableOffset, testName + " " + position + " left" ); + equal( event.clientY - ui.offset.top, testData.y + testHelper.unreliableOffset, testName + " " + position + " top" ); } } }); @@ -799,29 +799,29 @@ test( "disabled", function() { var element = $( "#draggable1" ).draggable(); - draggableTestHelpers.shouldMove( element, "disabled: default" ); + testHelper.shouldMove( element, "disabled: default" ); element.draggable( "option", "disabled", true ); - draggableTestHelpers.shouldNotDrag( element, "option: disabled true" ); + testHelper.shouldNotDrag( element, "option: disabled true" ); element.draggable( "option", "disabled", false ); - draggableTestHelpers.shouldMove( element, "option: disabled false" ); + testHelper.shouldMove( element, "option: disabled false" ); }); test( "{ grid: [50, 50] }, relative", function() { expect( 4 ); var element = $( "#draggable1" ).draggable({ grid: [ 50, 50 ] }); - draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] relative" ); - draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] relative" ); + testHelper.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] relative" ); + testHelper.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] relative" ); }); test( "{ grid: [50, 50] }, absolute", function() { expect( 4 ); var element = $( "#draggable2" ).draggable({ grid: [ 50, 50 ] }); - draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] absolute" ); - draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] absolute" ); + testHelper.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] absolute" ); + testHelper.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] absolute" ); }); test( "grid, switching after initialization", function() { @@ -830,13 +830,13 @@ test( "grid, switching after initialization", function() { var element = $( "#draggable1" ).draggable(); // Forward - draggableTestHelpers.testDrag( element, element, 24, 24, 24, 24, "grid: default" ); - draggableTestHelpers.testDrag( element, element, 0, 0, 0, 0, "grid: default" ); + testHelper.testDrag( element, element, 24, 24, 24, 24, "grid: default" ); + testHelper.testDrag( element, element, 0, 0, 0, 0, "grid: default" ); element.draggable( "option", "grid", [ 50, 50 ] ); - draggableTestHelpers.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] as option" ); - draggableTestHelpers.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] as option" ); + testHelper.testDrag( element, element, 24, 24, 0, 0, "grid: [50, 50] as option" ); + testHelper.testDrag( element, element, 26, 25, 50, 50, "grid: [50, 50] as option" ); }); test( "{ handle: 'span' }", function() { @@ -844,9 +844,9 @@ test( "{ handle: 'span' }", function() { var element = $( "#draggable2" ).draggable({ handle: "span" }); - draggableTestHelpers.shouldMove( element, "handle: span", "#draggable2 span"); - draggableTestHelpers.shouldMove( element, "handle: span child", "#draggable2 span em" ); - draggableTestHelpers.shouldNotDrag( element, "handle: span element" ); + testHelper.shouldMove( element, "handle: span", "#draggable2 span"); + testHelper.shouldMove( element, "handle: span child", "#draggable2 span em" ); + testHelper.shouldNotDrag( element, "handle: span element" ); }); test( "handle, default, switching after initialization", function() { @@ -854,31 +854,31 @@ test( "handle, default, switching after initialization", function() { var element = $( "#draggable2" ).draggable(); - draggableTestHelpers.shouldMove( element, "handle: default, element dragged" ); - draggableTestHelpers.shouldMove( element, "handle: default, span dragged", "#draggable2 span" ); + testHelper.shouldMove( element, "handle: default, element dragged" ); + testHelper.shouldMove( element, "handle: default, span dragged", "#draggable2 span" ); // Switch element.draggable( "option", "handle", "span" ); - draggableTestHelpers.shouldNotDrag( element, "handle: span as option, element dragged" ); - draggableTestHelpers.shouldMove( element, "handle: span as option, span dragged", "#draggable2 span" ); + testHelper.shouldNotDrag( element, "handle: span as option, element dragged" ); + testHelper.shouldMove( element, "handle: span as option, span dragged", "#draggable2 span" ); // And back element.draggable( "option", "handle", false ); - draggableTestHelpers.shouldMove( element, "handle: false as option, element dragged" ); - draggableTestHelpers.shouldMove( element, "handle: false as option, span dragged", "#draggable2 span" ); + testHelper.shouldMove( element, "handle: false as option, element dragged" ); + testHelper.shouldMove( element, "handle: false as option, span dragged", "#draggable2 span" ); }); test( "helper, default, switching after initialization", function() { expect( 6 ); var element = $( "#draggable1" ).draggable(); - draggableTestHelpers.shouldMove( element, "helper: default" ); + testHelper.shouldMove( element, "helper: default" ); element.draggable( "option", "helper", "clone" ); - draggableTestHelpers.shouldMove( element, "helper: clone" ); + testHelper.shouldMove( element, "helper: clone" ); element.draggable( "option", "helper", "original" ); - draggableTestHelpers.shouldMove( element, "helper: original" ); + testHelper.shouldMove( element, "helper: original" ); }); // http://bugs.jqueryui.com/ticket/9446 @@ -892,7 +892,7 @@ test( "helper, function returning original element", function() { } }); - draggableTestHelpers.testDragHelperOffset( element, 100, 100, 100, 100, "original element is draggable" ); + testHelper.testDragHelperOffset( element, 100, 100, 100, 100, "original element is draggable" ); element.simulate( "drag", { dx: 100, @@ -911,25 +911,25 @@ function testHelperPosition( scrollPositions, position, helper, scrollElements, }); if ( scrollElements.length === 1 && scrollElements[ 0 ] === "#scrollParent" ) { - draggableTestHelpers.setScrollable( "#main", false ); - draggableTestHelpers.setScrollable( "#scrollParent", true ); + testHelper.setScrollable( "#main", false ); + testHelper.setScrollable( "#scrollParent", true ); } for ( j = 0; j < scrollPositions.length; j++ ) { for ( i = 0; i < scrollElements.length; i++ ) { - draggableTestHelpers.setScroll( scrollElements[ i ] ); + testHelper.setScroll( scrollElements[ i ] ); } - draggableTestHelpers.testScroll( element, scrollPositions[ j ] ); + testHelper.testScroll( element, scrollPositions[ j ] ); for ( i = 0; i < scrollElements.length; i++ ) { - draggableTestHelpers.restoreScroll( scrollElements[ i ] ); + testHelper.restoreScroll( scrollElements[ i ] ); } } if ( scrollElements.length === 1 && scrollElements[ 1 ] === "#scrollParent" ) { - draggableTestHelpers.setScrollable( "#main", true ); - draggableTestHelpers.setScrollable( "#scrollParent", false ); + testHelper.setScrollable( "#main", true ); + testHelper.setScrollable( "#scrollParent", false ); } }); } @@ -987,15 +987,15 @@ test( "opacity, default, switching after initialization", function() { } }); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( opacity, 1 ); element.draggable( "option", "opacity", 0.5 ); - draggableTestHelpers.move( element, 2, 1 ); + testHelper.move( element, 2, 1 ); equal( opacity, 0.5 ); element.draggable( "option", "opacity", false ); - draggableTestHelpers.move( element, 3, 1 ); + testHelper.move( element, 3, 1 ); equal( opacity, 1 ); }); @@ -1006,13 +1006,13 @@ asyncTest( "revert and revertDuration", function() { revert: true, revertDuration: 0 }); - draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: true, revertDuration: 0 should revert immediately" ); + testHelper.shouldMovePositionButNotOffset( element, "revert: true, revertDuration: 0 should revert immediately" ); $( "#draggable2" ).draggable( "option", "revert", "invalid" ); - draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: invalid, revertDuration: 0 should revert immediately" ); + testHelper.shouldMovePositionButNotOffset( element, "revert: invalid, revertDuration: 0 should revert immediately" ); $( "#draggable2" ).draggable( "option", "revert", false ); - draggableTestHelpers.shouldMove( element, "revert: false should allow movement" ); + testHelper.shouldMove( element, "revert: false should allow movement" ); $( "#draggable2" ).draggable( "option", { revert: true, @@ -1023,7 +1023,7 @@ asyncTest( "revert and revertDuration", function() { }); // animation are async, so test for it asynchronously - draggableTestHelpers.move( element, 50, 50 ); + testHelper.move( element, 50, 50 ); setTimeout( function() { ok( $( "#draggable2" ).is( ":animated" ), "revert: true with revertDuration should animate" ); }); @@ -1039,7 +1039,7 @@ test( "revert: valid", function() { $( "#droppable" ).droppable(); - draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable" ); + testHelper.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable" ); }); test( "scope", function() { @@ -1053,17 +1053,17 @@ test( "scope", function() { $( "#droppable" ).droppable({ scope: "tasks" }); - draggableTestHelpers.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable in scope" ); + testHelper.shouldMovePositionButNotOffset( element, "revert: valid reverts when dropped on a droppable in scope" ); $( "#droppable" ).droppable( "destroy" ).droppable({ scope: "nottasks" }); - draggableTestHelpers.shouldMove( element, "revert: valid reverts when dropped on a droppable out of scope" ); + testHelper.shouldMove( element, "revert: valid reverts when dropped on a droppable out of scope" ); }); test( "scroll, scrollSensitivity, and scrollSpeed", function() { expect( 2 ); - draggableTestHelpers.setScrollable( "#main", false ); + testHelper.setScrollable( "#main", false ); var currentScrollTop, viewportHeight = $( window ).height(), @@ -1105,7 +1105,7 @@ test( "scroll, scrollSensitivity, and scrollSpeed", function() { moves: 1 }); - draggableTestHelpers.restoreScroll( document ); + testHelper.restoreScroll( document ); }); test( "scroll ignores containers that are overflow: hidden", function() { @@ -1144,7 +1144,7 @@ test( "scroll ignores containers that are overflow: hidden", function() { test( "#6817: auto scroll goes double distance when dragging", function( assert ) { expect( 2 ); - draggableTestHelpers.restoreScroll( document ); + testHelper.restoreScroll( document ); var offsetBefore, distance = 10, @@ -1175,7 +1175,7 @@ test( "#6817: auto scroll goes double distance when dragging", function( assert moves: 1 }); - draggableTestHelpers.restoreScroll( document ); + testHelper.restoreScroll( document ); }); test( "snap, snapMode, and snapTolerance", function( assert ) { @@ -1337,7 +1337,7 @@ test( "#8459: element can snap to an element that was removed during drag", func }); // Support: Opera 12.10, Safari 5.1, jQuery <1.8 - if ( draggableTestHelpers.unreliableContains ) { + if ( testHelper.unreliableContains ) { ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); ok( true, "Opera <12.14 and Safari <6.0 report wrong values for $.contains in jQuery < 1.8" ); } else { @@ -1394,10 +1394,10 @@ test( "stack", function() { stack: "#draggable1, #draggable2" }); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( element.css( "zIndex" ), "2", "stack increments zIndex correctly" ); - draggableTestHelpers.move( element2, 1, 1 ); + testHelper.move( element2, 1, 1 ); equal( element2.css( "zIndex" ), "3", "stack increments zIndex correctly" ); }); @@ -1435,15 +1435,15 @@ test( "zIndex, default, switching after initialization", function() { element.css( "z-index", 1 ); - draggableTestHelpers.move( element, 1, 1 ); + testHelper.move( element, 1, 1 ); equal( zindex, 1 ); element.draggable( "option", "zIndex", 5 ); - draggableTestHelpers.move( element, 2, 1 ); + testHelper.move( element, 2, 1 ); equal( zindex, 5 ); element.draggable( "option", "zIndex", false ); - draggableTestHelpers.move( element, 3, 1 ); + testHelper.move( element, 3, 1 ); equal( zindex, 1 ); }); diff --git a/tests/unit/draggable/draggable_test_helpers.js b/tests/unit/draggable/draggable_test_helpers.js index dcf2d62974d..1858e187b08 100644 --- a/tests/unit/draggable/draggable_test_helpers.js +++ b/tests/unit/draggable/draggable_test_helpers.js @@ -1,14 +1,20 @@ -define( function() { +define( [ + "jquery", + "lib/helper", + "ui/draggable" +], function( $, helper ) { -var draggableTestHelpers = { +return $.extend( helper, { // TODO: remove the unreliable offset hacks unreliableOffset: $.ui.ie && ( !document.documentMode || document.documentMode < 8 ) ? 2 : 0, // Support: Opera 12.10, Safari 5.1, jQuery <1.8 + unreliableContains: (function() { var element = $( "
" ); return $.contains( element[ 0 ].ownerDocument, element[ 0 ] ); })(), + testDragPosition: function( el, dx, dy, expectedDX, expectedDY, msg ) { msg = msg ? msg + "." : ""; @@ -17,6 +23,7 @@ var draggableTestHelpers = { deepEqual( ui.position, positionExpected, "position dragged[" + dx + ", " + dy + "] " + msg ); }); }, + testDragOffset: function( el, dx, dy, expectedDX, expectedDY, msg ) { msg = msg ? msg + "." : ""; @@ -27,6 +34,7 @@ var draggableTestHelpers = { deepEqual( ui.offset, offsetExpected, "offset dragged[" + dx + ", " + dy + "] " + msg ); }); }, + testDragHelperOffset: function( el, dx, dy, expectedDX, expectedDY, msg ) { msg = msg ? msg + "." : ""; @@ -37,33 +45,38 @@ var draggableTestHelpers = { deepEqual( ui.helper.offset(), offsetExpected, "offset dragged[" + dx + ", " + dy + "] " + msg ); }); }, + testDrag: function( el, handle, dx, dy, expectedDX, expectedDY, msg ) { - draggableTestHelpers.testDragPosition( el, dx, dy, expectedDX, expectedDY, msg ); - draggableTestHelpers.testDragOffset( el, dx, dy, expectedDX, expectedDY, msg ); + this.testDragPosition( el, dx, dy, expectedDX, expectedDY, msg ); + this.testDragOffset( el, dx, dy, expectedDX, expectedDY, msg ); $( handle ).simulate( "drag", { dx: dx, dy: dy }); }, + shouldMovePositionButNotOffset: function( el, msg, handle ) { handle = handle || el; - draggableTestHelpers.testDragPosition( el, 100, 100, 100, 100, msg ); - draggableTestHelpers.testDragHelperOffset( el, 100, 100, 0, 0, msg ); + this.testDragPosition( el, 100, 100, 100, 100, msg ); + this.testDragHelperOffset( el, 100, 100, 0, 0, msg ); $( handle ).simulate( "drag", { dx: 100, dy: 100 }); }, + shouldMove: function( el, msg, handle ) { handle = handle || el; - draggableTestHelpers.testDrag( el, handle, 100, 100, 100, 100, msg ); + this.testDrag( el, handle, 100, 100, 100, 100, msg ); }, + shouldNotMove: function( el, msg, handle ) { handle = handle || el; - draggableTestHelpers.testDrag( el, handle, 100, 100, 0, 0, msg ); + this.testDrag( el, handle, 100, 100, 0, 0, msg ); }, + shouldNotDrag: function( el, msg, handle ) { handle = handle || el; @@ -89,39 +102,48 @@ var draggableTestHelpers = { element.unbind( "dragstop" ); }, + setScrollable: function( what, isScrollable ) { var overflow = isScrollable ? "scroll" : "hidden"; $( what ).css({ overflow: overflow, overflowX: overflow, overflowY: overflow }); }, + testScroll: function( el, position ) { var oldPosition = $( "#main" ).css( "position" ); $( "#main" ).css({ position: position, top: "0px", left: "0px" }); - draggableTestHelpers.shouldMove( el, position + " parent" ); + this.shouldMove( el, position + " parent" ); $( "#main" ).css( "position", oldPosition ); }, + restoreScroll: function( what ) { $( what ).scrollTop( 0 ).scrollLeft( 0 ); }, + setScroll: function( what ) { $( what ).scrollTop( 100 ).scrollLeft( 100 ); }, + border: function( el, side ) { return parseInt( el.css( "border-" + side + "-width" ), 10 ) || 0; }, + margin: function( el, side ) { return parseInt( el.css( "margin-" + side ), 10 ) || 0; }, + move: function( el, x, y ) { $( el ).simulate( "drag", { dx: x, dy: y }); }, + trackMouseCss: function( el ) { el.bind( "drag", function() { el.data( "last_dragged_cursor", $( "body" ).css( "cursor" ) ); }); }, + trackAppendedParent: function( el ) { // TODO: appendTo is currently ignored if helper is original (see #7044) el.draggable( "option", "helper", "clone" ); @@ -131,8 +153,6 @@ var draggableTestHelpers = { el.data( "last_dragged_parent", ui.helper.parent()[ 0 ] ); }); } -}; - -return draggableTestHelpers; +} ); } ); diff --git a/tests/unit/droppable/droppable_core.js b/tests/unit/droppable/droppable_core.js index 9ea789544e0..25d052a59bd 100644 --- a/tests/unit/droppable/droppable_core.js +++ b/tests/unit/droppable/droppable_core.js @@ -2,7 +2,7 @@ define( [ "jquery", "./droppable_test_helpers", "ui/droppable" -], function( $, droppableTestHelpers ) { +], function( $, testHelper ) { module("droppable: core"); @@ -20,7 +20,7 @@ test("element types", function() { (typeName === "table" && el.append("content")); el.droppable(); - droppableTestHelpers.shouldDrop(); + testHelper.shouldDrop(); el.droppable("destroy"); el.remove(); }); diff --git a/tests/unit/droppable/droppable_methods.js b/tests/unit/droppable/droppable_methods.js index 70a60d2cbc2..816fed0ec28 100644 --- a/tests/unit/droppable/droppable_methods.js +++ b/tests/unit/droppable/droppable_methods.js @@ -2,7 +2,7 @@ define( [ "jquery", "./droppable_test_helpers", "ui/droppable" -], function( $, droppableTestHelpers ) { +], function( $, testHelper ) { module("droppable: methods"); @@ -48,16 +48,16 @@ test("enable", function() { var el, expected, actual; el = $("#droppable1").droppable({ disabled: true }); - droppableTestHelpers.shouldNotDrop(); + testHelper.shouldNotDrop(); el.droppable("enable"); - droppableTestHelpers.shouldDrop(); + testHelper.shouldDrop(); equal(el.droppable("option", "disabled"), false, "disabled option getter"); el.droppable("destroy"); el.droppable({ disabled: true }); - droppableTestHelpers.shouldNotDrop(); + testHelper.shouldNotDrop(); el.droppable("option", "disabled", false); equal(el.droppable("option", "disabled"), false, "disabled option setter"); - droppableTestHelpers.shouldDrop(); + testHelper.shouldDrop(); expected = $("
").droppable(), actual = expected.droppable("enable"); @@ -70,19 +70,19 @@ test( "disable", function( assert ) { var actual, expected, element = $( "#droppable1" ).droppable({ disabled: false }); - droppableTestHelpers.shouldDrop(); + testHelper.shouldDrop(); element.droppable( "disable" ); - droppableTestHelpers.shouldNotDrop(); + testHelper.shouldNotDrop(); equal( element.droppable( "option", "disabled" ), true, "disabled option getter" ); element.droppable( "destroy" ); element.droppable({ disabled: false }); - droppableTestHelpers.shouldDrop(); + testHelper.shouldDrop(); element.droppable( "option", "disabled", true ); assert.lacksClasses( element.droppable( "widget" ), "ui-state-disabled" ); ok( !element.droppable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); assert.hasClasses( element.droppable( "widget" ), "ui-droppable-disabled" ); equal( element.droppable( "option", "disabled" ), true, "disabled option setter" ); - droppableTestHelpers.shouldNotDrop(); + testHelper.shouldNotDrop(); expected = $( "
" ).droppable(); actual = expected.droppable( "disable" ); diff --git a/tests/unit/droppable/droppable_options.js b/tests/unit/droppable/droppable_options.js index 24a1a788eae..f2d1757c25b 100644 --- a/tests/unit/droppable/droppable_options.js +++ b/tests/unit/droppable/droppable_options.js @@ -1,6 +1,5 @@ define( [ "jquery", - "./droppable_test_helpers", "ui/droppable" ], function( $ ) { diff --git a/tests/unit/droppable/droppable_test_helpers.js b/tests/unit/droppable/droppable_test_helpers.js index 5ffb32f4c61..460fa1aa6c0 100644 --- a/tests/unit/droppable/droppable_test_helpers.js +++ b/tests/unit/droppable/droppable_test_helpers.js @@ -1,14 +1,18 @@ -define( function() { +define( [ + "jquery", + "lib/helper" +], function( $, helper ) { -return { +return $.extend( helper, { shouldDrop: function() { // todo: actually implement this ok(true, "missing test - untested code is broken code"); }, + shouldNotDrop: function() { // todo: actually implement this ok(true, "missing test - untested code is broken code"); } -}; +} ); } ); diff --git a/tests/unit/menu/menu_core.js b/tests/unit/menu/menu_core.js index 3dd2c78e13f..7ff127009da 100644 --- a/tests/unit/menu/menu_core.js +++ b/tests/unit/menu/menu_core.js @@ -2,7 +2,7 @@ define( [ "jquery", "./menu_test_helpers", "ui/menu" -], function( $, menuTestHelpers ) { +], function( $, testHelper ) { module( "menu: core" ); @@ -51,7 +51,7 @@ asyncTest( "#9044: Autofocus issue with dialog opened from menu widget", functio $( "#test9044" ).focus(); }); - menuTestHelpers.click( element, "3" ); + testHelper.click( element, "3" ); setTimeout( function() { equal( document.activeElement.id, "test9044", "Focus was swallowed by menu" ); $( "#test9044" ).remove(); diff --git a/tests/unit/menu/menu_events.js b/tests/unit/menu/menu_events.js index 3e2aa61bf43..610b1eaf396 100644 --- a/tests/unit/menu/menu_events.js +++ b/tests/unit/menu/menu_events.js @@ -2,15 +2,15 @@ define( [ "jquery", "./menu_test_helpers", "ui/menu" -], function( $, menuTestHelpers ) { +], function( $, testHelper ) { -var log = menuTestHelpers.log, - logOutput = menuTestHelpers.logOutput, - click = menuTestHelpers.click; +var log = testHelper.log, + logOutput = testHelper.logOutput, + click = testHelper.click; module( "menu: events", { setup: function() { - menuTestHelpers.clearLog(); + testHelper.clearLog(); } }); diff --git a/tests/unit/menu/menu_methods.js b/tests/unit/menu/menu_methods.js index ad30e5f138c..61be3229f8a 100644 --- a/tests/unit/menu/menu_methods.js +++ b/tests/unit/menu/menu_methods.js @@ -2,15 +2,15 @@ define( [ "jquery", "./menu_test_helpers", "ui/menu" -], function( $, menuTestHelpers ) { +], function( $, testHelper ) { -var log = menuTestHelpers.log, - logOutput = menuTestHelpers.logOutput, - click = menuTestHelpers.click; +var log = testHelper.log, + logOutput = testHelper.logOutput, + click = testHelper.click; module( "menu: methods", { setup: function() { - menuTestHelpers.clearLog(); + testHelper.clearLog(); } }); diff --git a/tests/unit/menu/menu_options.js b/tests/unit/menu/menu_options.js index 91630e14b20..762b057fb4d 100644 --- a/tests/unit/menu/menu_options.js +++ b/tests/unit/menu/menu_options.js @@ -2,15 +2,15 @@ define( [ "jquery", "./menu_test_helpers", "ui/menu" -], function( $, menuTestHelpers ) { +], function( $, testHelper ) { -var log = menuTestHelpers.log, - logOutput = menuTestHelpers.logOutput, - click = menuTestHelpers.click; +var log = testHelper.log, + logOutput = testHelper.logOutput, + click = testHelper.click; module( "menu: options", { setup: function() { - menuTestHelpers.clearLog(); + testHelper.clearLog(); } }); diff --git a/tests/unit/menu/menu_test_helpers.js b/tests/unit/menu/menu_test_helpers.js index bfed14d7403..4456639857c 100644 --- a/tests/unit/menu/menu_test_helpers.js +++ b/tests/unit/menu/menu_test_helpers.js @@ -1,9 +1,12 @@ -define( function() { +define( [ + "jquery", + "lib/helper" +], function( $, helper ) { var lastItem, log = []; -return { +return $.extend( helper, { log: function( message, clear ) { if ( clear ) { log.length = 0; @@ -28,6 +31,6 @@ return { .children( ".ui-menu-item-wrapper" ) .trigger( "click" ); } -}; +} ); } ); diff --git a/tests/unit/resizable/resizable_core.js b/tests/unit/resizable/resizable_core.js index 2e643c96768..a6318951133 100644 --- a/tests/unit/resizable/resizable_core.js +++ b/tests/unit/resizable/resizable_core.js @@ -2,7 +2,7 @@ define( [ "jquery", "./resizable_test_helpers", "ui/resizable" -], function( $, resizableTestHelpers ) { +], function( $, testHelper ) { module("resizable: core"); @@ -30,10 +30,10 @@ test("n", function() { var handle = ".ui-resizable-n", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, 0, -50); + testHelper.drag(handle, 0, -50); equal( target.height(), 150, "compare height" ); - resizableTestHelpers.drag(handle, 0, 50); + testHelper.drag(handle, 0, 50); equal( target.height(), 100, "compare height" ); equal( target[0].style.left, "", "left should not be modified" ); @@ -45,10 +45,10 @@ test("s", function() { var handle = ".ui-resizable-s", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, 0, 50); + testHelper.drag(handle, 0, 50); equal( target.height(), 150, "compare height" ); - resizableTestHelpers.drag(handle, 0, -50); + testHelper.drag(handle, 0, -50); equal( target.height(), 100, "compare height" ); equal( target[0].style.top, "", "top should not be modified" ); @@ -61,10 +61,10 @@ test("e", function() { var handle = ".ui-resizable-e", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, 50); + testHelper.drag(handle, 50); equal( target.width(), 150, "compare width"); - resizableTestHelpers.drag(handle, -50); + testHelper.drag(handle, -50); equal( target.width(), 100, "compare width" ); equal( target[0].style.height, "", "height should not be modified" ); @@ -77,10 +77,10 @@ test("w", function() { var handle = ".ui-resizable-w", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, -50); + testHelper.drag(handle, -50); equal( target.width(), 150, "compare width" ); - resizableTestHelpers.drag(handle, 50); + testHelper.drag(handle, 50); equal( target.width(), 100, "compare width" ); equal( target[0].style.height, "", "height should not be modified" ); @@ -92,11 +92,11 @@ test("ne", function() { var handle = ".ui-resizable-ne", target = $("#resizable1").css({ overflow: "hidden" }).resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, -50, -50); + testHelper.drag(handle, -50, -50); equal( target.width(), 50, "compare width" ); equal( target.height(), 150, "compare height" ); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -108,11 +108,11 @@ test("se", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal( target.width(), 150, "compare width" ); equal( target.height(), 150, "compare height" ); - resizableTestHelpers.drag(handle, -50, -50); + testHelper.drag(handle, -50, -50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -125,11 +125,11 @@ test("sw", function() { var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, -50, -50); + testHelper.drag(handle, -50, -50); equal( target.width(), 150, "compare width" ); equal( target.height(), 50, "compare height" ); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); @@ -141,11 +141,11 @@ test("nw", function() { var handle = ".ui-resizable-nw", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, -50, -50); + testHelper.drag(handle, -50, -50); equal( target.width(), 150, "compare width" ); equal( target.height(), 150, "compare height" ); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); }); @@ -163,10 +163,10 @@ test("handle with complex markup (#8756)", function() { var handle = ".ui-resizable-w div", target = $("#resizable1").resizable({ handles: "all" }); - resizableTestHelpers.drag(handle, -50); + testHelper.drag(handle, -50); equal( target.width(), 150, "compare width" ); - resizableTestHelpers.drag(handle, 50); + testHelper.drag(handle, 50); equal( target.width(), 100, "compare width" ); }); @@ -186,7 +186,7 @@ test("resizable accounts for scroll position correctly (#3815)", function() { left = el.css("left"); top = el.css("top"); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); deepEqual( el.position(), position, "position stays the same when resized" ); equal( el.css("left"), left, "css('left') stays the same when resized" ); equal( el.css("top"), top, "css('top') stays the same when resized" ); @@ -203,7 +203,7 @@ test( "resizable stores correct size when using helper and grid (#9547)", functi grid: [ 10, 10 ] }); - resizableTestHelpers.drag( handle, 1, 1 ); + testHelper.drag( handle, 1, 1 ); equal( target.width(), 100, "compare width" ); equal( target.height(), 100, "compare height" ); }); @@ -227,14 +227,14 @@ test( "nested resizable", function() { innerHandle = $( "#inner > .ui-resizable-e" ); outerHandle = $( "#outer > .ui-resizable-e" ); - resizableTestHelpers.drag( innerHandle, 10 ); + testHelper.drag( innerHandle, 10 ); equal( inner.width(), 40, "compare width of inner element" ); - resizableTestHelpers.drag( innerHandle, -10 ); + testHelper.drag( innerHandle, -10 ); equal( inner.width(), 30, "compare width of inner element" ); - resizableTestHelpers.drag( outerHandle, 10 ); + testHelper.drag( outerHandle, 10 ); equal( outer.width(), 60, "compare width of outer element" ); - resizableTestHelpers.drag( outerHandle, -10 ); + testHelper.drag( outerHandle, -10 ); equal( outer.width(), 50, "compare width of outer element" ); inner.remove(); diff --git a/tests/unit/resizable/resizable_events.js b/tests/unit/resizable/resizable_events.js index 62f2582398c..a26824137b9 100644 --- a/tests/unit/resizable/resizable_events.js +++ b/tests/unit/resizable/resizable_events.js @@ -2,7 +2,7 @@ define( [ "jquery", "./resizable_test_helpers", "ui/resizable" -], function( $, resizableTestHelpers ) { +], function( $, testHelper ) { module("resizable: events"); @@ -24,7 +24,7 @@ test("start", function() { } }); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal(count, 1, "start callback should happen exactly once"); @@ -55,7 +55,7 @@ test( "resize", function() { } }); - resizableTestHelpers.drag( handle, 50, 50 ); + testHelper.drag( handle, 50, 50 ); equal( count, 2, "resize callback should happen exactly once per size adjustment" ); @@ -83,7 +83,7 @@ test( "resize (min/max dimensions)", function() { } }); - resizableTestHelpers.drag( handle, -200, -200 ); + testHelper.drag( handle, -200, -200 ); equal( count, 1, "resize callback should happen exactly once per size adjustment" ); @@ -113,10 +113,10 @@ test( "resize (containment)", function() { }); // Prove you can't resize outside containment by dragging southeast corner southeast - resizableTestHelpers.drag( handle, 100, 100 ); + testHelper.drag( handle, 100, 100 ); // Prove you can't resize outside containment by dragging southeast corner northwest - resizableTestHelpers.drag( handle, -200, -200 ); + testHelper.drag( handle, -200, -200 ); equal( count, 1, "resize callback should happen exactly once per size adjustment" ); @@ -141,7 +141,7 @@ test("resize (grid)", function() { } }); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal(count, 1, "resize callback should happen exactly once per grid-unit size adjustment"); @@ -160,7 +160,7 @@ test( "resize, custom adjustment", function() { } }); - resizableTestHelpers.drag( handle, 50, 50 ); + testHelper.drag( handle, 50, 50 ); equal( element.width(), 100, "resize event can control width" ); equal( element.height(), 200, "resize event can control height" ); @@ -186,7 +186,7 @@ test("stop", function() { } }); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal(count, 1, "stop callback should happen exactly once"); @@ -231,7 +231,7 @@ test( "resize (containment) works with parent with negative offset", function() widthBefore = target.width(); - resizableTestHelpers.drag( handle, increaseWidthBy, 0 ); + testHelper.drag( handle, increaseWidthBy, 0 ); widthAfter = target.width(); diff --git a/tests/unit/resizable/resizable_options.js b/tests/unit/resizable/resizable_options.js index c296fe38cf2..bf9033f1391 100644 --- a/tests/unit/resizable/resizable_options.js +++ b/tests/unit/resizable/resizable_options.js @@ -2,7 +2,7 @@ define( [ "jquery", "./resizable_test_helpers", "ui/resizable" -], function( $, resizableTestHelpers ) { +], function( $, testHelper ) { module("resizable: options"); @@ -20,7 +20,7 @@ test( "alsoResize", function() { }), handle = ".ui-resizable-e"; - resizableTestHelpers.drag( handle, 80 ); + testHelper.drag( handle, 80 ); equal( element.width(), 180, "resizable width" ); equal( other.width(), 130, "alsoResize width" ); }); @@ -30,11 +30,11 @@ test("aspectRatio: 'preserve' (e)", function() { var handle = ".ui-resizable-e", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, 80); + testHelper.drag(handle, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, -130); + testHelper.drag(handle, -130); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -44,11 +44,11 @@ test("aspectRatio: 'preserve' (w)", function() { var handle = ".ui-resizable-w", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, -80); + testHelper.drag(handle, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, 130); + testHelper.drag(handle, 130); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -58,11 +58,11 @@ test("aspectRatio: 'preserve' (n)", function() { var handle = ".ui-resizable-n", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, 0, -80); + testHelper.drag(handle, 0, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, 0, 80); + testHelper.drag(handle, 0, 80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -72,11 +72,11 @@ test("aspectRatio: 'preserve' (s)", function() { var handle = ".ui-resizable-s", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, 0, 80); + testHelper.drag(handle, 0, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, 0, -80); + testHelper.drag(handle, 0, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -86,11 +86,11 @@ test("aspectRatio: 'preserve' (se)", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, 80, 80); + testHelper.drag(handle, 80, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, -80, -80); + testHelper.drag(handle, -80, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -100,11 +100,11 @@ test("aspectRatio: 'preserve' (sw)", function() { var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, -80, 80); + testHelper.drag(handle, -80, 80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, 80, -80); + testHelper.drag(handle, 80, -80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -114,11 +114,11 @@ test("aspectRatio: 'preserve' (ne)", function() { var handle = ".ui-resizable-ne", target = $("#resizable1").resizable({ aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 }); - resizableTestHelpers.drag(handle, 80, -80); + testHelper.drag(handle, 80, -80); equal( target.width(), 130, "compare maxWidth"); equal( target.height(), 130, "compare maxHeight"); - resizableTestHelpers.drag(handle, -80, 80); + testHelper.drag(handle, -80, 80); equal( target.width(), 70, "compare minWidth"); equal( target.height(), 70, "compare minHeight"); }); @@ -138,7 +138,7 @@ test( "aspectRatio: Resizing can move objects", function() { $( "#container" ).css({ width: 200, height: 300 }); $( "#resizable1" ).css({ width: 100, height: 100, left: 75, top: 200 }); - resizableTestHelpers.drag( handleW, -20 ); + testHelper.drag( handleW, -20 ); equal( target.width(), 100, "compare width - no size change" ); equal( target.height(), 100, "compare height - no size change" ); equal( target.position().left, 75, "compare left - no movement" ); @@ -147,7 +147,7 @@ test( "aspectRatio: Resizing can move objects", function() { $( "#container" ).css({ width: 200, height: 300, position: "absolute", left: 100, top: 100 }); $( "#resizable1" ).css({ width: 100, height: 100, left: 0, top: 0 }); - resizableTestHelpers.drag( handleNW, -20, -20 ); + testHelper.drag( handleNW, -20, -20 ); equal( target.width(), 100, "compare width - no size change" ); equal( target.height(), 100, "compare height - no size change" ); equal( target.position().left, 0, "compare left - no movement" ); @@ -161,11 +161,11 @@ test( "containment", function() { containment: "#container" }); - resizableTestHelpers.drag( ".ui-resizable-se", 20, 30 ); + testHelper.drag( ".ui-resizable-se", 20, 30 ); equal( element.width(), 120, "unconstrained width within container" ); equal( element.height(), 130, "unconstrained height within container" ); - resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); + testHelper.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "constrained width at containment edge" ); equal( element.height(), 200, "constrained height at containment edge" ); }); @@ -180,10 +180,10 @@ test( "containment - not immediate parent", function() { handles: "all" }); - resizableTestHelpers.drag( ".ui-resizable-e", 300, 0 ); + testHelper.drag( ".ui-resizable-e", 300, 0 ); equal( element.width(), 400, "Relative, contained within container width" ); - resizableTestHelpers.drag( ".ui-resizable-s", 0, 300 ); + testHelper.drag( ".ui-resizable-s", 0, 300 ); equal( element.height(), 400, "Relative, contained within container height" ); $( "#child" ).css( { left: 50, top: 50 } ); @@ -195,10 +195,10 @@ test( "containment - not immediate parent", function() { handles: "all" }); - resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); + testHelper.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 300, "Relative with Left, contained within container width" ); - resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); + testHelper.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 300, "Relative with Top, contained within container height" ); }); @@ -212,10 +212,10 @@ test( "containment - immediate parent", function() { handles: "all" }); - resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); + testHelper.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 300, "Relative, contained within container width" ); - resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); + testHelper.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 300, "Relative, contained within container height" ); $( "#child" ).css( { left: 50, top: 50 } ); @@ -227,10 +227,10 @@ test( "containment - immediate parent", function() { handles: "all" }); - resizableTestHelpers.drag( ".ui-resizable-e", 400, 0 ); + testHelper.drag( ".ui-resizable-e", 400, 0 ); equal( element.width(), 250, "Relative with Left, contained within container width" ); - resizableTestHelpers.drag( ".ui-resizable-s", 0, 400 ); + testHelper.drag( ".ui-resizable-s", 0, 400 ); equal( element.height(), 250, "Relative with Top, contained within container height" ); }); @@ -239,11 +239,11 @@ test("grid", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", grid: [ 0, 20 ] }); - resizableTestHelpers.drag(handle, 3, 9); + testHelper.drag(handle, 3, 9); equal( target.width(), 103, "compare width"); equal( target.height(), 100, "compare height"); - resizableTestHelpers.drag(handle, 15, 11); + testHelper.drag(handle, 15, 11); equal( target.width(), 118, "compare width"); equal( target.height(), 120, "compare height"); }); @@ -253,11 +253,11 @@ test("grid (min/max dimensions)", function() { var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", grid: 20, minWidth: 65, minHeight: 65, maxWidth: 135, maxHeight: 135 }); - resizableTestHelpers.drag(handle, 50, 50); + testHelper.drag(handle, 50, 50); equal( target.width(), 120, "grid should respect maxWidth"); equal( target.height(), 120, "grid should respect maxHeight"); - resizableTestHelpers.drag(handle, -100, -100); + testHelper.drag(handle, -100, -100); equal( target.width(), 80, "grid should respect minWidth"); equal( target.height(), 80, "grid should respect minHeight"); }); @@ -267,11 +267,11 @@ test("grid (wrapped)", function() { var handle = ".ui-resizable-se", target = $("#resizable2").resizable({ handles: "all", grid: [ 0, 20 ] }); - resizableTestHelpers.drag(handle, 3, 9); + testHelper.drag(handle, 3, 9); equal( target.width(), 103, "compare width"); equal( target.height(), 100, "compare height"); - resizableTestHelpers.drag(handle, 15, 11); + testHelper.drag(handle, 15, 11); equal( target.width(), 118, "compare width"); equal( target.height(), 120, "compare height"); }); @@ -286,13 +286,13 @@ test( "grid - Resizable: can be moved when grid option is set (#9611)", function grid: 50 }); - resizableTestHelpers.drag( handle, 50, 50 ); + testHelper.drag( handle, 50, 50 ); equal( target.width(), 50, "compare width" ); equal( target.height(), 50, "compare height" ); oldPosition = target.position(); - resizableTestHelpers.drag( handle, 50, 50 ); + testHelper.drag( handle, 50, 50 ); equal( target.width(), 50, "compare width" ); equal( target.height(), 50, "compare height" ); equal( target.position().top, oldPosition.top, "compare top" ); @@ -314,7 +314,7 @@ test( "grid - maintains grid with padding and border when approaching no dimensi grid: [ 50, 12 ] }); - resizableTestHelpers.drag( handle, 50, 50 ); + testHelper.drag( handle, 50, 50 ); equal( target.outerWidth(), 50, "compare width" ); equal( target.outerHeight(), 52, "compare height" ); }); @@ -324,11 +324,11 @@ test("ui-resizable-se { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-se", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - resizableTestHelpers.drag(handle, -50, -50); + testHelper.drag(handle, -50, -50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - resizableTestHelpers.drag(handle, 70, 70); + testHelper.drag(handle, 70, 70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -338,11 +338,11 @@ test("ui-resizable-sw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-sw", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - resizableTestHelpers.drag(handle, 50, -50); + testHelper.drag(handle, 50, -50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - resizableTestHelpers.drag(handle, -70, 70); + testHelper.drag(handle, -70, 70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -352,11 +352,11 @@ test("ui-resizable-ne { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-ne", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - resizableTestHelpers.drag(handle, -50, 50); + testHelper.drag(handle, -50, 50); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - resizableTestHelpers.drag(handle, 70, -70); + testHelper.drag(handle, 70, -70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -366,11 +366,11 @@ test("ui-resizable-nw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 1 var handle = ".ui-resizable-nw", target = $("#resizable1").resizable({ handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }); - resizableTestHelpers.drag(handle, 70, 70); + testHelper.drag(handle, 70, 70); equal( target.width(), 60, "compare minWidth" ); equal( target.height(), 60, "compare minHeight" ); - resizableTestHelpers.drag(handle, -70, -70); + testHelper.drag(handle, -70, -70); equal( target.width(), 100, "compare maxWidth" ); equal( target.height(), 100, "compare maxHeight" ); }); @@ -382,10 +382,10 @@ test( "custom handles { handles: { 's': $('#resizer1'), containment: 'parent' }" var handle = "#resizer1", target = $( "#resizable1" ).resizable({ handles: { "s": $( "#resizer1" ) }, containment: "parent" }); - resizableTestHelpers.drag( handle, 0, 70 ); + testHelper.drag( handle, 0, 70 ); equal( target.height(), 170, "compare height" ); - resizableTestHelpers.drag( handle, 0, -70 ); + testHelper.drag( handle, 0, -70 ); equal( target.height(), 100, "compare height" ); }); @@ -396,10 +396,10 @@ test( "custom handles { handles: { 's': $('#resizer1')[0], containment: 'parent' var handle = "#resizer1", target = $( "#resizable1" ).resizable({ handles: { "s": $( "#resizer1" )[ 0 ] }, containment: "parent" }); - resizableTestHelpers.drag( handle, 0, 70 ); + testHelper.drag( handle, 0, 70 ); equal( target.height(), 170, "compare height" ); - resizableTestHelpers.drag( handle, 0, -70 ); + testHelper.drag( handle, 0, -70 ); equal( target.height(), 100, "compare height" ); }); @@ -426,7 +426,7 @@ test( "alsoResize + containment", function() { containment: "#container" }); - resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); + testHelper.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "resizable constrained width at containment edge" ); equal( element.height(), 200, "resizable constrained height at containment edge" ); equal( other.width(), 250, "alsoResize constrained width at containment edge" ); @@ -454,7 +454,7 @@ test( "alsoResize + multiple selection", function() { containment: "#container" }); - resizableTestHelpers.drag( ".ui-resizable-se", 400, 400 ); + testHelper.drag( ".ui-resizable-se", 400, 400 ); equal( element.width(), 300, "resizable constrained width at containment edge" ); equal( element.height(), 200, "resizable constrained height at containment edge" ); equal( other1.width(), 250, "alsoResize o1 constrained width at containment edge" ); diff --git a/tests/unit/resizable/resizable_test_helpers.js b/tests/unit/resizable/resizable_test_helpers.js index 1c2ec831b5a..494c1a07385 100644 --- a/tests/unit/resizable/resizable_test_helpers.js +++ b/tests/unit/resizable/resizable_test_helpers.js @@ -1,6 +1,9 @@ -define( function() { +define( [ + "jquery", + "lib/helper" +], function( $, helper ) { -return { +return $.extend( helper, { drag: function( el, dx, dy ) { // this mouseover is to work around a limitation in resizable // TODO: fix resizable so handle doesn't require mouseover in order to be used @@ -10,6 +13,6 @@ return { dy: dy }); } -}; +} ); } ); diff --git a/tests/unit/sortable/sortable_core.js b/tests/unit/sortable/sortable_core.js index 0a750618410..64bdb661e2d 100644 --- a/tests/unit/sortable/sortable_core.js +++ b/tests/unit/sortable/sortable_core.js @@ -2,7 +2,7 @@ define( [ "jquery", "./sortable_test_helpers", "ui/sortable" -], function( $, sortableTestHelpers ) { +], function( $, testHelper ) { module( "sortable: core" ); @@ -13,7 +13,7 @@ test( "#9314: Sortable: Items cannot be dragged directly into bottom position", connectWith: ".connectWith" }); - sortableTestHelpers.sort( $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" ); + testHelper.sort( $( "li", el[ 1 ] )[ 0 ], 0, -12, 5, "Dragging the sortable into connected sortable" ); }); test( "ui-sortable-handle applied to appropriate element", function( assert ) { diff --git a/tests/unit/sortable/sortable_events.js b/tests/unit/sortable/sortable_events.js index 2bf9efe3042..453b8b7b69a 100644 --- a/tests/unit/sortable/sortable_events.js +++ b/tests/unit/sortable/sortable_events.js @@ -3,7 +3,7 @@ define( [ "./sortable_test_helpers", "ui/sortable", "ui/draggable" -], function( $, sortableTestHelpers ) { +], function( $, testHelper ) { module("sortable: events"); @@ -172,7 +172,7 @@ test("#3019: Stop fires too early", function() { } }); - sortableTestHelpers.sort($("li", el)[0], 0, 44, 2, "Dragging the sortable"); + testHelper.sort($("li", el)[0], 0, 44, 2, "Dragging the sortable"); equal(helper, null, "helper should be false"); }); diff --git a/tests/unit/sortable/sortable_methods.js b/tests/unit/sortable/sortable_methods.js index b1057fc8e7b..d3bb23d6ee7 100644 --- a/tests/unit/sortable/sortable_methods.js +++ b/tests/unit/sortable/sortable_methods.js @@ -2,7 +2,7 @@ define( [ "jquery", "./sortable_test_helpers", "ui/sortable" -], function( $, sortableTestHelpers ) { +], function( $, testHelper ) { module("sortable: methods"); @@ -48,7 +48,7 @@ test("enable", function() { el = $("#sortable").sortable({ disabled: true }); - sortableTestHelpers.sort($("li", el)[0], 0, 44, 0, ".sortable({ disabled: true })"); + testHelper.sort($("li", el)[0], 0, 44, 0, ".sortable({ disabled: true })"); el.sortable("enable"); equal(el.sortable("option", "disabled"), false, "disabled option getter"); @@ -58,7 +58,7 @@ test("enable", function() { el.sortable("option", "disabled", false); equal(el.sortable("option", "disabled"), false, "disabled option setter"); - sortableTestHelpers.sort($("li", el)[0], 0, 44, 2, ".sortable('option', 'disabled', false)"); + testHelper.sort($("li", el)[0], 0, 44, 2, ".sortable('option', 'disabled', false)"); expected = $("
").sortable(), actual = expected.sortable("enable"); @@ -71,15 +71,15 @@ test( "disable", function( assert ) { var chainable, element = $( "#sortable" ).sortable({ disabled: false }); - sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); + testHelper.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); chainable = element.sortable( "disable" ); - sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" ); + testHelper.sort( $( "li", element )[ 0 ], 0, 44, 0, "disabled.sortable getter" ); element.sortable( "destroy" ); element.sortable({ disabled: false }); - sortableTestHelpers.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); + testHelper.sort( $( "li", element )[ 0 ], 0, 44, 2, ".sortable({ disabled: false })" ); element.sortable( "option", "disabled", true); equal( element.sortable( "option", "disabled" ), true, "disabled option setter" ); @@ -87,7 +87,7 @@ test( "disable", function( assert ) { ok( !element.sortable( "widget" ).attr( "aria-disabled" ), "element does not get aria-disabled" ); assert.hasClasses( element.sortable( "widget" ), "ui-sortable-disabled" ); - sortableTestHelpers.sort($( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" ); + testHelper.sort($( "li", element )[ 0 ], 0, 44, 0, ".sortable('option', 'disabled', true)" ); equal( chainable, element, "disable is chainable" ); }); diff --git a/tests/unit/sortable/sortable_test_helpers.js b/tests/unit/sortable/sortable_test_helpers.js index 5f4f8aca69d..76545022ee2 100644 --- a/tests/unit/sortable/sortable_test_helpers.js +++ b/tests/unit/sortable/sortable_test_helpers.js @@ -1,6 +1,9 @@ -define( function() { +define( [ + "jquery", + "lib/helper" +], function( $, helper ) { -return { +return $.extend( helper, { sort: function( handle, dx, dy, index, msg ) { $( handle ).simulate( "drag", { dx: dx, @@ -8,6 +11,6 @@ return { }); equal( $( handle ).parent().children().index( handle ), index, msg ); } -}; +} ); } ); diff --git a/tests/unit/spinner/spinner_core.js b/tests/unit/spinner/spinner_core.js index 5faa733c35f..d0388a57504 100644 --- a/tests/unit/spinner/spinner_core.js +++ b/tests/unit/spinner/spinner_core.js @@ -2,9 +2,9 @@ define( [ "jquery", "./spinner_test_helpers", "ui/spinner" -], function( $, spinnerTestHelpers ) { +], function( $, testHelper ) { -var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; +var simulateKeyDownUp = testHelper.simulateKeyDownUp; module( "spinner: core" ); diff --git a/tests/unit/spinner/spinner_events.js b/tests/unit/spinner/spinner_events.js index 05d1efe1b72..a37d6134620 100644 --- a/tests/unit/spinner/spinner_events.js +++ b/tests/unit/spinner/spinner_events.js @@ -2,9 +2,9 @@ define( [ "jquery", "./spinner_test_helpers", "ui/spinner" -], function( $, spinnerTestHelpers ) { +], function( $, testHelper ) { -var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; +var simulateKeyDownUp = testHelper.simulateKeyDownUp; module( "spinner: events" ); diff --git a/tests/unit/spinner/spinner_methods.js b/tests/unit/spinner/spinner_methods.js index 3f88a9e9c7f..75ae5c9e83f 100644 --- a/tests/unit/spinner/spinner_methods.js +++ b/tests/unit/spinner/spinner_methods.js @@ -2,9 +2,9 @@ define( [ "jquery", "./spinner_test_helpers", "ui/spinner" -], function( $, spinnerTestHelpers ) { +], function( $, testHelper ) { -var simulateKeyDownUp = spinnerTestHelpers.simulateKeyDownUp; +var simulateKeyDownUp = testHelper.simulateKeyDownUp; module( "spinner: methods" ); diff --git a/tests/unit/spinner/spinner_test_helpers.js b/tests/unit/spinner/spinner_test_helpers.js index 9ed904ff451..ab99dcd8e3b 100644 --- a/tests/unit/spinner/spinner_test_helpers.js +++ b/tests/unit/spinner/spinner_test_helpers.js @@ -1,11 +1,14 @@ -define( function() { +define( [ + "jquery", + "lib/helper" +], function( $, helper ) { -return { +return $.extend( helper, { simulateKeyDownUp: function( element, keyCode, shift ) { element .simulate( "keydown", { keyCode: keyCode, shiftKey: shift || false } ) .simulate( "keyup", { keyCode: keyCode, shiftKey: shift || false } ); } -}; +} ); } ); diff --git a/tests/unit/tabs/tabs_core.js b/tests/unit/tabs/tabs_core.js index c7eb237044e..2e39ca0e6d5 100644 --- a/tests/unit/tabs/tabs_core.js +++ b/tests/unit/tabs/tabs_core.js @@ -2,9 +2,9 @@ define( [ "jquery", "./tabs_test_helpers", "ui/tabs" -], function( $, tabsTestHelpers ) { +], function( $, testHelper ) { -var state = tabsTestHelpers.state; +var state = testHelper.state; module( "tabs: core" ); diff --git a/tests/unit/tabs/tabs_events.js b/tests/unit/tabs/tabs_events.js index b5972242d53..fb274624828 100644 --- a/tests/unit/tabs/tabs_events.js +++ b/tests/unit/tabs/tabs_events.js @@ -2,9 +2,9 @@ define( [ "jquery", "./tabs_test_helpers", "ui/tabs" -], function( $, tabsTestHelpers ) { +], function( $, testHelper ) { -var state = tabsTestHelpers.state; +var state = testHelper.state; module( "tabs: events" ); diff --git a/tests/unit/tabs/tabs_methods.js b/tests/unit/tabs/tabs_methods.js index cd4ed3581e3..fc1ff6dd6df 100644 --- a/tests/unit/tabs/tabs_methods.js +++ b/tests/unit/tabs/tabs_methods.js @@ -2,10 +2,10 @@ define( [ "jquery", "./tabs_test_helpers", "ui/tabs" -], function( $, tabsTestHelpers ) { +], function( $, testHelper ) { -var disabled = tabsTestHelpers.disabled, - state = tabsTestHelpers.state; +var disabled = testHelper.disabled, + state = testHelper.state; module( "tabs: methods" ); diff --git a/tests/unit/tabs/tabs_options.js b/tests/unit/tabs/tabs_options.js index 13b88b040d0..e4c3efa1542 100644 --- a/tests/unit/tabs/tabs_options.js +++ b/tests/unit/tabs/tabs_options.js @@ -2,11 +2,11 @@ define( [ "jquery", "./tabs_test_helpers", "ui/tabs" -], function( $, tabsTestHelpers ) { +], function( $, testHelper ) { -var disabled = tabsTestHelpers.disabled, - equalHeight = tabsTestHelpers.equalHeight, - state = tabsTestHelpers.state; +var disabled = testHelper.disabled, + equalHeight = testHelper.equalHeight, + state = testHelper.state; module( "tabs: options" ); diff --git a/tests/unit/tabs/tabs_test_helpers.js b/tests/unit/tabs/tabs_test_helpers.js index 8d35c31db40..5c9625f8c5f 100644 --- a/tests/unit/tabs/tabs_test_helpers.js +++ b/tests/unit/tabs/tabs_test_helpers.js @@ -1,6 +1,10 @@ -define( function() { +define( [ + "jquery", + "lib/helper", + "ui/tabs" +], function( $, helper ) { -return { +return $.extend( helper, { disabled: function( tabs, state ) { var expected, actual, internalState = tabs.tabs( "option", "disabled" ); @@ -65,6 +69,6 @@ return { }).get(); deepEqual( actual, expected ); } -}; +} ); } ); From 3065df6293f1205602c9daef192f82dd2a865c25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Tue, 7 Apr 2015 10:55:52 -0400 Subject: [PATCH 27/29] Tests: Rename files --- tests/lib/bootstrap.js | 12 ++++++------ .../accordion/{accordion_common.js => common.js} | 0 tests/unit/accordion/{accordion_core.js => core.js} | 2 +- .../accordion/{accordion_events.js => events.js} | 2 +- .../{accordion_test_helpers.js => helper.js} | 0 .../accordion/{accordion_methods.js => methods.js} | 2 +- .../accordion/{accordion_options.js => options.js} | 2 +- .../{autocomplete_common.js => common.js} | 0 .../autocomplete/{autocomplete_core.js => core.js} | 0 .../{autocomplete_events.js => events.js} | 0 .../{autocomplete_methods.js => methods.js} | 0 .../{autocomplete_options.js => options.js} | 0 tests/unit/button/{button_common.js => common.js} | 0 tests/unit/button/{button_core.js => core.js} | 0 tests/unit/button/{button_events.js => events.js} | 0 tests/unit/button/{button_methods.js => methods.js} | 0 tests/unit/button/{button_options.js => options.js} | 0 .../datepicker/{datepicker_common.js => common.js} | 0 .../unit/datepicker/{datepicker_core.js => core.js} | 2 +- .../datepicker/{datepicker_events.js => events.js} | 2 +- .../{datepicker_test_helpers.js => helper.js} | 0 .../datepicker/{datepicker_methods.js => methods.js} | 2 +- .../datepicker/{datepicker_options.js => options.js} | 2 +- ...log_common_deprecated.js => common-deprecated.js} | 0 tests/unit/dialog/{dialog_common.js => common.js} | 0 tests/unit/dialog/{dialog_core.js => core.js} | 0 .../{dialog_deprecated.html => deprecated.html} | 0 .../dialog/{dialog_deprecated.js => deprecated.js} | 0 tests/unit/dialog/{dialog_events.js => events.js} | 2 +- .../dialog/{dialog_test_helpers.js => helper.js} | 0 tests/unit/dialog/{dialog_methods.js => methods.js} | 0 tests/unit/dialog/{dialog_options.js => options.js} | 2 +- .../draggable/{draggable_common.js => common.js} | 0 tests/unit/draggable/{draggable_core.js => core.js} | 2 +- .../draggable/{draggable_events.js => events.js} | 0 .../{draggable_test_helpers.js => helper.js} | 0 .../draggable/{draggable_methods.js => methods.js} | 2 +- .../draggable/{draggable_options.js => options.js} | 2 +- ...ble_common_deprecated.js => common-deprecated.js} | 0 .../droppable/{droppable_common.js => common.js} | 0 tests/unit/droppable/{droppable_core.js => core.js} | 2 +- .../{droppable_deprecated.html => deprecated.html} | 0 .../{droppable_deprecated.js => deprecated.js} | 0 .../droppable/{droppable_events.js => events.js} | 0 .../{droppable_test_helpers.js => helper.js} | 0 .../droppable/{droppable_methods.js => methods.js} | 2 +- .../droppable/{droppable_options.js => options.js} | 0 tests/unit/effects/{effects_core.js => core.js} | 0 tests/unit/effects/effects.html | 2 +- tests/unit/effects/{effects_scale.js => scale.js} | 0 tests/unit/menu/{menu_common.js => common.js} | 0 tests/unit/menu/{menu_core.js => core.js} | 2 +- tests/unit/menu/{menu_events.js => events.js} | 2 +- tests/unit/menu/{menu_test_helpers.js => helper.js} | 0 tests/unit/menu/{menu_methods.js => methods.js} | 2 +- tests/unit/menu/{menu_options.js => options.js} | 2 +- tests/unit/position/{position_core.js => core.js} | 0 tests/unit/position/position.html | 2 +- .../progressbar/{progressbar_common.js => common.js} | 0 .../progressbar/{progressbar_core.js => core.js} | 0 .../progressbar/{progressbar_events.js => events.js} | 0 .../{progressbar_methods.js => methods.js} | 0 .../{progressbar_options.js => options.js} | 0 .../resizable/{resizable_common.js => common.js} | 0 tests/unit/resizable/{resizable_core.js => core.js} | 2 +- .../resizable/{resizable_events.js => events.js} | 2 +- .../{resizable_test_helpers.js => helper.js} | 0 .../resizable/{resizable_methods.js => methods.js} | 0 .../resizable/{resizable_options.js => options.js} | 2 +- .../selectable/{selectable_common.js => common.js} | 0 .../unit/selectable/{selectable_core.js => core.js} | 0 .../selectable/{selectable_events.js => events.js} | 0 .../selectable/{selectable_methods.js => methods.js} | 0 .../selectable/{selectable_options.js => options.js} | 0 .../selectmenu/{selectmenu_common.js => common.js} | 0 .../unit/selectmenu/{selectmenu_core.js => core.js} | 0 .../selectmenu/{selectmenu_events.js => events.js} | 0 .../selectmenu/{selectmenu_methods.js => methods.js} | 0 .../selectmenu/{selectmenu_options.js => options.js} | 0 tests/unit/slider/{slider_common.js => common.js} | 0 tests/unit/slider/{slider_core.js => core.js} | 0 tests/unit/slider/{slider_events.js => events.js} | 0 tests/unit/slider/{slider_methods.js => methods.js} | 0 tests/unit/slider/{slider_options.js => options.js} | 0 .../unit/sortable/{sortable_common.js => common.js} | 0 tests/unit/sortable/{sortable_core.js => core.js} | 2 +- .../unit/sortable/{sortable_events.js => events.js} | 2 +- .../sortable/{sortable_test_helpers.js => helper.js} | 0 .../sortable/{sortable_methods.js => methods.js} | 2 +- .../sortable/{sortable_options.js => options.js} | 0 tests/unit/spinner/{spinner_common.js => common.js} | 0 tests/unit/spinner/{spinner_core.js => core.js} | 2 +- tests/unit/spinner/{spinner_events.js => events.js} | 2 +- .../spinner/{spinner_test_helpers.js => helper.js} | 0 .../unit/spinner/{spinner_methods.js => methods.js} | 2 +- .../unit/spinner/{spinner_options.js => options.js} | 0 tests/unit/tabs/{tabs_common.js => common.js} | 0 tests/unit/tabs/{tabs_core.js => core.js} | 2 +- tests/unit/tabs/{tabs_events.js => events.js} | 2 +- tests/unit/tabs/{tabs_test_helpers.js => helper.js} | 0 tests/unit/tabs/{tabs_methods.js => methods.js} | 2 +- tests/unit/tabs/{tabs_options.js => options.js} | 2 +- ...tip_common_deprecated.js => common-deprecated.js} | 0 tests/unit/tooltip/{tooltip_common.js => common.js} | 0 tests/unit/tooltip/{tooltip_core.js => core.js} | 0 .../{tooltip_deprecated.html => deprecated.html} | 0 .../tooltip/{tooltip_deprecated.js => deprecated.js} | 0 tests/unit/tooltip/{tooltip_events.js => events.js} | 0 .../unit/tooltip/{tooltip_methods.js => methods.js} | 0 .../unit/tooltip/{tooltip_options.js => options.js} | 0 .../widget/{widget_animation.js => animation.js} | 0 tests/unit/widget/{widget_classes.js => classes.js} | 0 tests/unit/widget/{widget_core.js => core.js} | 0 tests/unit/widget/{widget_extend.js => extend.js} | 0 tests/unit/widget/widget.html | 8 +------- 115 files changed, 41 insertions(+), 47 deletions(-) rename tests/unit/accordion/{accordion_common.js => common.js} (100%) rename tests/unit/accordion/{accordion_core.js => core.js} (99%) rename tests/unit/accordion/{accordion_events.js => events.js} (99%) rename tests/unit/accordion/{accordion_test_helpers.js => helper.js} (100%) rename tests/unit/accordion/{accordion_methods.js => methods.js} (99%) rename tests/unit/accordion/{accordion_options.js => options.js} (99%) rename tests/unit/autocomplete/{autocomplete_common.js => common.js} (100%) rename tests/unit/autocomplete/{autocomplete_core.js => core.js} (100%) rename tests/unit/autocomplete/{autocomplete_events.js => events.js} (100%) rename tests/unit/autocomplete/{autocomplete_methods.js => methods.js} (100%) rename tests/unit/autocomplete/{autocomplete_options.js => options.js} (100%) rename tests/unit/button/{button_common.js => common.js} (100%) rename tests/unit/button/{button_core.js => core.js} (100%) rename tests/unit/button/{button_events.js => events.js} (100%) rename tests/unit/button/{button_methods.js => methods.js} (100%) rename tests/unit/button/{button_options.js => options.js} (100%) rename tests/unit/datepicker/{datepicker_common.js => common.js} (100%) rename tests/unit/datepicker/{datepicker_core.js => core.js} (99%) rename tests/unit/datepicker/{datepicker_events.js => events.js} (99%) rename tests/unit/datepicker/{datepicker_test_helpers.js => helper.js} (100%) rename tests/unit/datepicker/{datepicker_methods.js => methods.js} (99%) rename tests/unit/datepicker/{datepicker_options.js => options.js} (99%) rename tests/unit/dialog/{dialog_common_deprecated.js => common-deprecated.js} (100%) rename tests/unit/dialog/{dialog_common.js => common.js} (100%) rename tests/unit/dialog/{dialog_core.js => core.js} (100%) rename tests/unit/dialog/{dialog_deprecated.html => deprecated.html} (100%) rename tests/unit/dialog/{dialog_deprecated.js => deprecated.js} (100%) rename tests/unit/dialog/{dialog_events.js => events.js} (99%) rename tests/unit/dialog/{dialog_test_helpers.js => helper.js} (100%) rename tests/unit/dialog/{dialog_methods.js => methods.js} (100%) rename tests/unit/dialog/{dialog_options.js => options.js} (99%) rename tests/unit/draggable/{draggable_common.js => common.js} (100%) rename tests/unit/draggable/{draggable_core.js => core.js} (99%) rename tests/unit/draggable/{draggable_events.js => events.js} (100%) rename tests/unit/draggable/{draggable_test_helpers.js => helper.js} (100%) rename tests/unit/draggable/{draggable_methods.js => methods.js} (99%) rename tests/unit/draggable/{draggable_options.js => options.js} (99%) rename tests/unit/droppable/{droppable_common_deprecated.js => common-deprecated.js} (100%) rename tests/unit/droppable/{droppable_common.js => common.js} (100%) rename tests/unit/droppable/{droppable_core.js => core.js} (95%) rename tests/unit/droppable/{droppable_deprecated.html => deprecated.html} (100%) rename tests/unit/droppable/{droppable_deprecated.js => deprecated.js} (100%) rename tests/unit/droppable/{droppable_events.js => events.js} (100%) rename tests/unit/droppable/{droppable_test_helpers.js => helper.js} (100%) rename tests/unit/droppable/{droppable_methods.js => methods.js} (98%) rename tests/unit/droppable/{droppable_options.js => options.js} (100%) rename tests/unit/effects/{effects_core.js => core.js} (100%) rename tests/unit/effects/{effects_scale.js => scale.js} (100%) rename tests/unit/menu/{menu_common.js => common.js} (100%) rename tests/unit/menu/{menu_core.js => core.js} (99%) rename tests/unit/menu/{menu_events.js => events.js} (99%) rename tests/unit/menu/{menu_test_helpers.js => helper.js} (100%) rename tests/unit/menu/{menu_methods.js => methods.js} (99%) rename tests/unit/menu/{menu_options.js => options.js} (99%) rename tests/unit/position/{position_core.js => core.js} (100%) rename tests/unit/progressbar/{progressbar_common.js => common.js} (100%) rename tests/unit/progressbar/{progressbar_core.js => core.js} (100%) rename tests/unit/progressbar/{progressbar_events.js => events.js} (100%) rename tests/unit/progressbar/{progressbar_methods.js => methods.js} (100%) rename tests/unit/progressbar/{progressbar_options.js => options.js} (100%) rename tests/unit/resizable/{resizable_common.js => common.js} (100%) rename tests/unit/resizable/{resizable_core.js => core.js} (99%) rename tests/unit/resizable/{resizable_events.js => events.js} (99%) rename tests/unit/resizable/{resizable_test_helpers.js => helper.js} (100%) rename tests/unit/resizable/{resizable_methods.js => methods.js} (100%) rename tests/unit/resizable/{resizable_options.js => options.js} (99%) rename tests/unit/selectable/{selectable_common.js => common.js} (100%) rename tests/unit/selectable/{selectable_core.js => core.js} (100%) rename tests/unit/selectable/{selectable_events.js => events.js} (100%) rename tests/unit/selectable/{selectable_methods.js => methods.js} (100%) rename tests/unit/selectable/{selectable_options.js => options.js} (100%) rename tests/unit/selectmenu/{selectmenu_common.js => common.js} (100%) rename tests/unit/selectmenu/{selectmenu_core.js => core.js} (100%) rename tests/unit/selectmenu/{selectmenu_events.js => events.js} (100%) rename tests/unit/selectmenu/{selectmenu_methods.js => methods.js} (100%) rename tests/unit/selectmenu/{selectmenu_options.js => options.js} (100%) rename tests/unit/slider/{slider_common.js => common.js} (100%) rename tests/unit/slider/{slider_core.js => core.js} (100%) rename tests/unit/slider/{slider_events.js => events.js} (100%) rename tests/unit/slider/{slider_methods.js => methods.js} (100%) rename tests/unit/slider/{slider_options.js => options.js} (100%) rename tests/unit/sortable/{sortable_common.js => common.js} (100%) rename tests/unit/sortable/{sortable_core.js => core.js} (97%) rename tests/unit/sortable/{sortable_events.js => events.js} (99%) rename tests/unit/sortable/{sortable_test_helpers.js => helper.js} (100%) rename tests/unit/sortable/{sortable_methods.js => methods.js} (99%) rename tests/unit/sortable/{sortable_options.js => options.js} (100%) rename tests/unit/spinner/{spinner_common.js => common.js} (100%) rename tests/unit/spinner/{spinner_core.js => core.js} (99%) rename tests/unit/spinner/{spinner_events.js => events.js} (99%) rename tests/unit/spinner/{spinner_test_helpers.js => helper.js} (100%) rename tests/unit/spinner/{spinner_methods.js => methods.js} (99%) rename tests/unit/spinner/{spinner_options.js => options.js} (100%) rename tests/unit/tabs/{tabs_common.js => common.js} (100%) rename tests/unit/tabs/{tabs_core.js => core.js} (99%) rename tests/unit/tabs/{tabs_events.js => events.js} (99%) rename tests/unit/tabs/{tabs_test_helpers.js => helper.js} (100%) rename tests/unit/tabs/{tabs_methods.js => methods.js} (99%) rename tests/unit/tabs/{tabs_options.js => options.js} (99%) rename tests/unit/tooltip/{tooltip_common_deprecated.js => common-deprecated.js} (100%) rename tests/unit/tooltip/{tooltip_common.js => common.js} (100%) rename tests/unit/tooltip/{tooltip_core.js => core.js} (100%) rename tests/unit/tooltip/{tooltip_deprecated.html => deprecated.html} (100%) rename tests/unit/tooltip/{tooltip_deprecated.js => deprecated.js} (100%) rename tests/unit/tooltip/{tooltip_events.js => events.js} (100%) rename tests/unit/tooltip/{tooltip_methods.js => methods.js} (100%) rename tests/unit/tooltip/{tooltip_options.js => options.js} (100%) rename tests/unit/widget/{widget_animation.js => animation.js} (100%) rename tests/unit/widget/{widget_classes.js => classes.js} (100%) rename tests/unit/widget/{widget_core.js => core.js} (100%) rename tests/unit/widget/{widget_extend.js => extend.js} (100%) diff --git a/tests/lib/bootstrap.js b/tests/lib/bootstrap.js index b9598c6dfc4..6d608f2ebf2 100644 --- a/tests/lib/bootstrap.js +++ b/tests/lib/bootstrap.js @@ -123,14 +123,14 @@ function swarmInject() { if ( widget ) { modules = modules.concat([ - widget + ( deprecated ? "_common_deprecated" : "_common" ), - widget + "_core", - widget + "_events", - widget + "_methods", - widget + "_options" + ( deprecated ? "common-deprecated" : "common" ), + "core", + "events", + "methods", + "options" ]); if ( deprecated ) { - modules = modules.concat( widget + "_deprecated" ); + modules = modules.concat( "deprecated" ); } } diff --git a/tests/unit/accordion/accordion_common.js b/tests/unit/accordion/common.js similarity index 100% rename from tests/unit/accordion/accordion_common.js rename to tests/unit/accordion/common.js diff --git a/tests/unit/accordion/accordion_core.js b/tests/unit/accordion/core.js similarity index 99% rename from tests/unit/accordion/accordion_core.js rename to tests/unit/accordion/core.js index bd3b5675220..b1d45f77efa 100644 --- a/tests/unit/accordion/accordion_core.js +++ b/tests/unit/accordion/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./accordion_test_helpers", + "./helper", "ui/accordion" ], function( $, testHelper ) { diff --git a/tests/unit/accordion/accordion_events.js b/tests/unit/accordion/events.js similarity index 99% rename from tests/unit/accordion/accordion_events.js rename to tests/unit/accordion/events.js index ac05df30d34..7f7390c8312 100644 --- a/tests/unit/accordion/accordion_events.js +++ b/tests/unit/accordion/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./accordion_test_helpers", + "./helper", "ui/accordion" ], function( $, testHelper ) { diff --git a/tests/unit/accordion/accordion_test_helpers.js b/tests/unit/accordion/helper.js similarity index 100% rename from tests/unit/accordion/accordion_test_helpers.js rename to tests/unit/accordion/helper.js diff --git a/tests/unit/accordion/accordion_methods.js b/tests/unit/accordion/methods.js similarity index 99% rename from tests/unit/accordion/accordion_methods.js rename to tests/unit/accordion/methods.js index f33996c36e5..efabfed10b1 100644 --- a/tests/unit/accordion/accordion_methods.js +++ b/tests/unit/accordion/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./accordion_test_helpers", + "./helper", "ui/accordion" ], function( $, testHelper ) { diff --git a/tests/unit/accordion/accordion_options.js b/tests/unit/accordion/options.js similarity index 99% rename from tests/unit/accordion/accordion_options.js rename to tests/unit/accordion/options.js index d33241dac60..c95738c4395 100644 --- a/tests/unit/accordion/accordion_options.js +++ b/tests/unit/accordion/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./accordion_test_helpers", + "./helper", "ui/accordion" ], function( $, testHelper ) { diff --git a/tests/unit/autocomplete/autocomplete_common.js b/tests/unit/autocomplete/common.js similarity index 100% rename from tests/unit/autocomplete/autocomplete_common.js rename to tests/unit/autocomplete/common.js diff --git a/tests/unit/autocomplete/autocomplete_core.js b/tests/unit/autocomplete/core.js similarity index 100% rename from tests/unit/autocomplete/autocomplete_core.js rename to tests/unit/autocomplete/core.js diff --git a/tests/unit/autocomplete/autocomplete_events.js b/tests/unit/autocomplete/events.js similarity index 100% rename from tests/unit/autocomplete/autocomplete_events.js rename to tests/unit/autocomplete/events.js diff --git a/tests/unit/autocomplete/autocomplete_methods.js b/tests/unit/autocomplete/methods.js similarity index 100% rename from tests/unit/autocomplete/autocomplete_methods.js rename to tests/unit/autocomplete/methods.js diff --git a/tests/unit/autocomplete/autocomplete_options.js b/tests/unit/autocomplete/options.js similarity index 100% rename from tests/unit/autocomplete/autocomplete_options.js rename to tests/unit/autocomplete/options.js diff --git a/tests/unit/button/button_common.js b/tests/unit/button/common.js similarity index 100% rename from tests/unit/button/button_common.js rename to tests/unit/button/common.js diff --git a/tests/unit/button/button_core.js b/tests/unit/button/core.js similarity index 100% rename from tests/unit/button/button_core.js rename to tests/unit/button/core.js diff --git a/tests/unit/button/button_events.js b/tests/unit/button/events.js similarity index 100% rename from tests/unit/button/button_events.js rename to tests/unit/button/events.js diff --git a/tests/unit/button/button_methods.js b/tests/unit/button/methods.js similarity index 100% rename from tests/unit/button/button_methods.js rename to tests/unit/button/methods.js diff --git a/tests/unit/button/button_options.js b/tests/unit/button/options.js similarity index 100% rename from tests/unit/button/button_options.js rename to tests/unit/button/options.js diff --git a/tests/unit/datepicker/datepicker_common.js b/tests/unit/datepicker/common.js similarity index 100% rename from tests/unit/datepicker/datepicker_common.js rename to tests/unit/datepicker/common.js diff --git a/tests/unit/datepicker/datepicker_core.js b/tests/unit/datepicker/core.js similarity index 99% rename from tests/unit/datepicker/datepicker_core.js rename to tests/unit/datepicker/core.js index a1e75848ab8..f6e0dd58f6a 100644 --- a/tests/unit/datepicker/datepicker_core.js +++ b/tests/unit/datepicker/core.js @@ -1,7 +1,7 @@ define( [ "jquery", "lib/common", - "./datepicker_test_helpers", + "./helper", "ui/datepicker", "ui/i18n/datepicker-he" ], function( $, common, testHelper ) { diff --git a/tests/unit/datepicker/datepicker_events.js b/tests/unit/datepicker/events.js similarity index 99% rename from tests/unit/datepicker/datepicker_events.js rename to tests/unit/datepicker/events.js index 04a4cbfe845..ea69c1aaab5 100644 --- a/tests/unit/datepicker/datepicker_events.js +++ b/tests/unit/datepicker/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./datepicker_test_helpers", + "./helper", "ui/datepicker" ], function( $, testHelper ) { diff --git a/tests/unit/datepicker/datepicker_test_helpers.js b/tests/unit/datepicker/helper.js similarity index 100% rename from tests/unit/datepicker/datepicker_test_helpers.js rename to tests/unit/datepicker/helper.js diff --git a/tests/unit/datepicker/datepicker_methods.js b/tests/unit/datepicker/methods.js similarity index 99% rename from tests/unit/datepicker/datepicker_methods.js rename to tests/unit/datepicker/methods.js index 3899779a9c7..14fefacc2ab 100644 --- a/tests/unit/datepicker/datepicker_methods.js +++ b/tests/unit/datepicker/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./datepicker_test_helpers", + "./helper", "ui/datepicker" ], function( $, testHelper ) { diff --git a/tests/unit/datepicker/datepicker_options.js b/tests/unit/datepicker/options.js similarity index 99% rename from tests/unit/datepicker/datepicker_options.js rename to tests/unit/datepicker/options.js index ee4a3bae462..c8a30678b6b 100644 --- a/tests/unit/datepicker/datepicker_options.js +++ b/tests/unit/datepicker/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./datepicker_test_helpers", + "./helper", "ui/datepicker", "ui/i18n/datepicker-fr", "ui/i18n/datepicker-he", diff --git a/tests/unit/dialog/dialog_common_deprecated.js b/tests/unit/dialog/common-deprecated.js similarity index 100% rename from tests/unit/dialog/dialog_common_deprecated.js rename to tests/unit/dialog/common-deprecated.js diff --git a/tests/unit/dialog/dialog_common.js b/tests/unit/dialog/common.js similarity index 100% rename from tests/unit/dialog/dialog_common.js rename to tests/unit/dialog/common.js diff --git a/tests/unit/dialog/dialog_core.js b/tests/unit/dialog/core.js similarity index 100% rename from tests/unit/dialog/dialog_core.js rename to tests/unit/dialog/core.js diff --git a/tests/unit/dialog/dialog_deprecated.html b/tests/unit/dialog/deprecated.html similarity index 100% rename from tests/unit/dialog/dialog_deprecated.html rename to tests/unit/dialog/deprecated.html diff --git a/tests/unit/dialog/dialog_deprecated.js b/tests/unit/dialog/deprecated.js similarity index 100% rename from tests/unit/dialog/dialog_deprecated.js rename to tests/unit/dialog/deprecated.js diff --git a/tests/unit/dialog/dialog_events.js b/tests/unit/dialog/events.js similarity index 99% rename from tests/unit/dialog/dialog_events.js rename to tests/unit/dialog/events.js index cc5bef8fa80..5834b348118 100644 --- a/tests/unit/dialog/dialog_events.js +++ b/tests/unit/dialog/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./dialog_test_helpers", + "./helper", "ui/dialog" ], function( $, testHelper ) { diff --git a/tests/unit/dialog/dialog_test_helpers.js b/tests/unit/dialog/helper.js similarity index 100% rename from tests/unit/dialog/dialog_test_helpers.js rename to tests/unit/dialog/helper.js diff --git a/tests/unit/dialog/dialog_methods.js b/tests/unit/dialog/methods.js similarity index 100% rename from tests/unit/dialog/dialog_methods.js rename to tests/unit/dialog/methods.js diff --git a/tests/unit/dialog/dialog_options.js b/tests/unit/dialog/options.js similarity index 99% rename from tests/unit/dialog/dialog_options.js rename to tests/unit/dialog/options.js index 1b9af7a095b..c33a97c0180 100644 --- a/tests/unit/dialog/dialog_options.js +++ b/tests/unit/dialog/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./dialog_test_helpers", + "./helper", "ui/dialog", "ui/effect-blind", "ui/effect-explode" diff --git a/tests/unit/draggable/draggable_common.js b/tests/unit/draggable/common.js similarity index 100% rename from tests/unit/draggable/draggable_common.js rename to tests/unit/draggable/common.js diff --git a/tests/unit/draggable/draggable_core.js b/tests/unit/draggable/core.js similarity index 99% rename from tests/unit/draggable/draggable_core.js rename to tests/unit/draggable/core.js index 9df8f4da701..ef55026ee10 100644 --- a/tests/unit/draggable/draggable_core.js +++ b/tests/unit/draggable/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./draggable_test_helpers", + "./helper", "ui/draggable", "ui/droppable", "ui/resizable" diff --git a/tests/unit/draggable/draggable_events.js b/tests/unit/draggable/events.js similarity index 100% rename from tests/unit/draggable/draggable_events.js rename to tests/unit/draggable/events.js diff --git a/tests/unit/draggable/draggable_test_helpers.js b/tests/unit/draggable/helper.js similarity index 100% rename from tests/unit/draggable/draggable_test_helpers.js rename to tests/unit/draggable/helper.js diff --git a/tests/unit/draggable/draggable_methods.js b/tests/unit/draggable/methods.js similarity index 99% rename from tests/unit/draggable/draggable_methods.js rename to tests/unit/draggable/methods.js index 74c5b67e80b..195e9e2fba4 100644 --- a/tests/unit/draggable/draggable_methods.js +++ b/tests/unit/draggable/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./draggable_test_helpers", + "./helper", "ui/draggable" ], function( $, testHelper ) { diff --git a/tests/unit/draggable/draggable_options.js b/tests/unit/draggable/options.js similarity index 99% rename from tests/unit/draggable/draggable_options.js rename to tests/unit/draggable/options.js index 5368103b789..877b4275c35 100644 --- a/tests/unit/draggable/draggable_options.js +++ b/tests/unit/draggable/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./draggable_test_helpers", + "./helper", "ui/draggable", "ui/droppable", "ui/sortable" diff --git a/tests/unit/droppable/droppable_common_deprecated.js b/tests/unit/droppable/common-deprecated.js similarity index 100% rename from tests/unit/droppable/droppable_common_deprecated.js rename to tests/unit/droppable/common-deprecated.js diff --git a/tests/unit/droppable/droppable_common.js b/tests/unit/droppable/common.js similarity index 100% rename from tests/unit/droppable/droppable_common.js rename to tests/unit/droppable/common.js diff --git a/tests/unit/droppable/droppable_core.js b/tests/unit/droppable/core.js similarity index 95% rename from tests/unit/droppable/droppable_core.js rename to tests/unit/droppable/core.js index 25d052a59bd..43608353da0 100644 --- a/tests/unit/droppable/droppable_core.js +++ b/tests/unit/droppable/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./droppable_test_helpers", + "./helper", "ui/droppable" ], function( $, testHelper ) { diff --git a/tests/unit/droppable/droppable_deprecated.html b/tests/unit/droppable/deprecated.html similarity index 100% rename from tests/unit/droppable/droppable_deprecated.html rename to tests/unit/droppable/deprecated.html diff --git a/tests/unit/droppable/droppable_deprecated.js b/tests/unit/droppable/deprecated.js similarity index 100% rename from tests/unit/droppable/droppable_deprecated.js rename to tests/unit/droppable/deprecated.js diff --git a/tests/unit/droppable/droppable_events.js b/tests/unit/droppable/events.js similarity index 100% rename from tests/unit/droppable/droppable_events.js rename to tests/unit/droppable/events.js diff --git a/tests/unit/droppable/droppable_test_helpers.js b/tests/unit/droppable/helper.js similarity index 100% rename from tests/unit/droppable/droppable_test_helpers.js rename to tests/unit/droppable/helper.js diff --git a/tests/unit/droppable/droppable_methods.js b/tests/unit/droppable/methods.js similarity index 98% rename from tests/unit/droppable/droppable_methods.js rename to tests/unit/droppable/methods.js index 816fed0ec28..1c9bba023fa 100644 --- a/tests/unit/droppable/droppable_methods.js +++ b/tests/unit/droppable/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./droppable_test_helpers", + "./helper", "ui/droppable" ], function( $, testHelper ) { diff --git a/tests/unit/droppable/droppable_options.js b/tests/unit/droppable/options.js similarity index 100% rename from tests/unit/droppable/droppable_options.js rename to tests/unit/droppable/options.js diff --git a/tests/unit/effects/effects_core.js b/tests/unit/effects/core.js similarity index 100% rename from tests/unit/effects/effects_core.js rename to tests/unit/effects/core.js diff --git a/tests/unit/effects/effects.html b/tests/unit/effects/effects.html index d444d3853a6..91c31428c67 100644 --- a/tests/unit/effects/effects.html +++ b/tests/unit/effects/effects.html @@ -5,7 +5,7 @@ jQuery UI Effects Test Suite - #qunit-fixture { diff --git a/tests/unit/effects/effects_scale.js b/tests/unit/effects/scale.js similarity index 100% rename from tests/unit/effects/effects_scale.js rename to tests/unit/effects/scale.js diff --git a/tests/unit/menu/menu_common.js b/tests/unit/menu/common.js similarity index 100% rename from tests/unit/menu/menu_common.js rename to tests/unit/menu/common.js diff --git a/tests/unit/menu/menu_core.js b/tests/unit/menu/core.js similarity index 99% rename from tests/unit/menu/menu_core.js rename to tests/unit/menu/core.js index 7ff127009da..08644c31f34 100644 --- a/tests/unit/menu/menu_core.js +++ b/tests/unit/menu/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./menu_test_helpers", + "./helper", "ui/menu" ], function( $, testHelper ) { diff --git a/tests/unit/menu/menu_events.js b/tests/unit/menu/events.js similarity index 99% rename from tests/unit/menu/menu_events.js rename to tests/unit/menu/events.js index 610b1eaf396..e22f8ed43e1 100644 --- a/tests/unit/menu/menu_events.js +++ b/tests/unit/menu/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./menu_test_helpers", + "./helper", "ui/menu" ], function( $, testHelper ) { diff --git a/tests/unit/menu/menu_test_helpers.js b/tests/unit/menu/helper.js similarity index 100% rename from tests/unit/menu/menu_test_helpers.js rename to tests/unit/menu/helper.js diff --git a/tests/unit/menu/menu_methods.js b/tests/unit/menu/methods.js similarity index 99% rename from tests/unit/menu/menu_methods.js rename to tests/unit/menu/methods.js index 61be3229f8a..e322ab2144f 100644 --- a/tests/unit/menu/menu_methods.js +++ b/tests/unit/menu/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./menu_test_helpers", + "./helper", "ui/menu" ], function( $, testHelper ) { diff --git a/tests/unit/menu/menu_options.js b/tests/unit/menu/options.js similarity index 99% rename from tests/unit/menu/menu_options.js rename to tests/unit/menu/options.js index 762b057fb4d..8994b026f5a 100644 --- a/tests/unit/menu/menu_options.js +++ b/tests/unit/menu/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./menu_test_helpers", + "./helper", "ui/menu" ], function( $, testHelper ) { diff --git a/tests/unit/position/position_core.js b/tests/unit/position/core.js similarity index 100% rename from tests/unit/position/position_core.js rename to tests/unit/position/core.js diff --git a/tests/unit/position/position.html b/tests/unit/position/position.html index 1d408728117..e36ab5480cb 100644 --- a/tests/unit/position/position.html +++ b/tests/unit/position/position.html @@ -5,7 +5,7 @@ jQuery UI Position Test Suite - +
diff --git a/tests/unit/progressbar/progressbar_common.js b/tests/unit/progressbar/common.js similarity index 100% rename from tests/unit/progressbar/progressbar_common.js rename to tests/unit/progressbar/common.js diff --git a/tests/unit/progressbar/progressbar_core.js b/tests/unit/progressbar/core.js similarity index 100% rename from tests/unit/progressbar/progressbar_core.js rename to tests/unit/progressbar/core.js diff --git a/tests/unit/progressbar/progressbar_events.js b/tests/unit/progressbar/events.js similarity index 100% rename from tests/unit/progressbar/progressbar_events.js rename to tests/unit/progressbar/events.js diff --git a/tests/unit/progressbar/progressbar_methods.js b/tests/unit/progressbar/methods.js similarity index 100% rename from tests/unit/progressbar/progressbar_methods.js rename to tests/unit/progressbar/methods.js diff --git a/tests/unit/progressbar/progressbar_options.js b/tests/unit/progressbar/options.js similarity index 100% rename from tests/unit/progressbar/progressbar_options.js rename to tests/unit/progressbar/options.js diff --git a/tests/unit/resizable/resizable_common.js b/tests/unit/resizable/common.js similarity index 100% rename from tests/unit/resizable/resizable_common.js rename to tests/unit/resizable/common.js diff --git a/tests/unit/resizable/resizable_core.js b/tests/unit/resizable/core.js similarity index 99% rename from tests/unit/resizable/resizable_core.js rename to tests/unit/resizable/core.js index a6318951133..8c21fbd7d29 100644 --- a/tests/unit/resizable/resizable_core.js +++ b/tests/unit/resizable/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./resizable_test_helpers", + "./helper", "ui/resizable" ], function( $, testHelper ) { diff --git a/tests/unit/resizable/resizable_events.js b/tests/unit/resizable/events.js similarity index 99% rename from tests/unit/resizable/resizable_events.js rename to tests/unit/resizable/events.js index a26824137b9..2a06f87ccf0 100644 --- a/tests/unit/resizable/resizable_events.js +++ b/tests/unit/resizable/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./resizable_test_helpers", + "./helper", "ui/resizable" ], function( $, testHelper ) { diff --git a/tests/unit/resizable/resizable_test_helpers.js b/tests/unit/resizable/helper.js similarity index 100% rename from tests/unit/resizable/resizable_test_helpers.js rename to tests/unit/resizable/helper.js diff --git a/tests/unit/resizable/resizable_methods.js b/tests/unit/resizable/methods.js similarity index 100% rename from tests/unit/resizable/resizable_methods.js rename to tests/unit/resizable/methods.js diff --git a/tests/unit/resizable/resizable_options.js b/tests/unit/resizable/options.js similarity index 99% rename from tests/unit/resizable/resizable_options.js rename to tests/unit/resizable/options.js index bf9033f1391..7d9615b6424 100644 --- a/tests/unit/resizable/resizable_options.js +++ b/tests/unit/resizable/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./resizable_test_helpers", + "./helper", "ui/resizable" ], function( $, testHelper ) { diff --git a/tests/unit/selectable/selectable_common.js b/tests/unit/selectable/common.js similarity index 100% rename from tests/unit/selectable/selectable_common.js rename to tests/unit/selectable/common.js diff --git a/tests/unit/selectable/selectable_core.js b/tests/unit/selectable/core.js similarity index 100% rename from tests/unit/selectable/selectable_core.js rename to tests/unit/selectable/core.js diff --git a/tests/unit/selectable/selectable_events.js b/tests/unit/selectable/events.js similarity index 100% rename from tests/unit/selectable/selectable_events.js rename to tests/unit/selectable/events.js diff --git a/tests/unit/selectable/selectable_methods.js b/tests/unit/selectable/methods.js similarity index 100% rename from tests/unit/selectable/selectable_methods.js rename to tests/unit/selectable/methods.js diff --git a/tests/unit/selectable/selectable_options.js b/tests/unit/selectable/options.js similarity index 100% rename from tests/unit/selectable/selectable_options.js rename to tests/unit/selectable/options.js diff --git a/tests/unit/selectmenu/selectmenu_common.js b/tests/unit/selectmenu/common.js similarity index 100% rename from tests/unit/selectmenu/selectmenu_common.js rename to tests/unit/selectmenu/common.js diff --git a/tests/unit/selectmenu/selectmenu_core.js b/tests/unit/selectmenu/core.js similarity index 100% rename from tests/unit/selectmenu/selectmenu_core.js rename to tests/unit/selectmenu/core.js diff --git a/tests/unit/selectmenu/selectmenu_events.js b/tests/unit/selectmenu/events.js similarity index 100% rename from tests/unit/selectmenu/selectmenu_events.js rename to tests/unit/selectmenu/events.js diff --git a/tests/unit/selectmenu/selectmenu_methods.js b/tests/unit/selectmenu/methods.js similarity index 100% rename from tests/unit/selectmenu/selectmenu_methods.js rename to tests/unit/selectmenu/methods.js diff --git a/tests/unit/selectmenu/selectmenu_options.js b/tests/unit/selectmenu/options.js similarity index 100% rename from tests/unit/selectmenu/selectmenu_options.js rename to tests/unit/selectmenu/options.js diff --git a/tests/unit/slider/slider_common.js b/tests/unit/slider/common.js similarity index 100% rename from tests/unit/slider/slider_common.js rename to tests/unit/slider/common.js diff --git a/tests/unit/slider/slider_core.js b/tests/unit/slider/core.js similarity index 100% rename from tests/unit/slider/slider_core.js rename to tests/unit/slider/core.js diff --git a/tests/unit/slider/slider_events.js b/tests/unit/slider/events.js similarity index 100% rename from tests/unit/slider/slider_events.js rename to tests/unit/slider/events.js diff --git a/tests/unit/slider/slider_methods.js b/tests/unit/slider/methods.js similarity index 100% rename from tests/unit/slider/slider_methods.js rename to tests/unit/slider/methods.js diff --git a/tests/unit/slider/slider_options.js b/tests/unit/slider/options.js similarity index 100% rename from tests/unit/slider/slider_options.js rename to tests/unit/slider/options.js diff --git a/tests/unit/sortable/sortable_common.js b/tests/unit/sortable/common.js similarity index 100% rename from tests/unit/sortable/sortable_common.js rename to tests/unit/sortable/common.js diff --git a/tests/unit/sortable/sortable_core.js b/tests/unit/sortable/core.js similarity index 97% rename from tests/unit/sortable/sortable_core.js rename to tests/unit/sortable/core.js index 64bdb661e2d..7e973ec0533 100644 --- a/tests/unit/sortable/sortable_core.js +++ b/tests/unit/sortable/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./sortable_test_helpers", + "./helper", "ui/sortable" ], function( $, testHelper ) { diff --git a/tests/unit/sortable/sortable_events.js b/tests/unit/sortable/events.js similarity index 99% rename from tests/unit/sortable/sortable_events.js rename to tests/unit/sortable/events.js index 453b8b7b69a..174da203d24 100644 --- a/tests/unit/sortable/sortable_events.js +++ b/tests/unit/sortable/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./sortable_test_helpers", + "./helper", "ui/sortable", "ui/draggable" ], function( $, testHelper ) { diff --git a/tests/unit/sortable/sortable_test_helpers.js b/tests/unit/sortable/helper.js similarity index 100% rename from tests/unit/sortable/sortable_test_helpers.js rename to tests/unit/sortable/helper.js diff --git a/tests/unit/sortable/sortable_methods.js b/tests/unit/sortable/methods.js similarity index 99% rename from tests/unit/sortable/sortable_methods.js rename to tests/unit/sortable/methods.js index d3bb23d6ee7..d88b8089fd4 100644 --- a/tests/unit/sortable/sortable_methods.js +++ b/tests/unit/sortable/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./sortable_test_helpers", + "./helper", "ui/sortable" ], function( $, testHelper ) { diff --git a/tests/unit/sortable/sortable_options.js b/tests/unit/sortable/options.js similarity index 100% rename from tests/unit/sortable/sortable_options.js rename to tests/unit/sortable/options.js diff --git a/tests/unit/spinner/spinner_common.js b/tests/unit/spinner/common.js similarity index 100% rename from tests/unit/spinner/spinner_common.js rename to tests/unit/spinner/common.js diff --git a/tests/unit/spinner/spinner_core.js b/tests/unit/spinner/core.js similarity index 99% rename from tests/unit/spinner/spinner_core.js rename to tests/unit/spinner/core.js index d0388a57504..aabfd7aa5b5 100644 --- a/tests/unit/spinner/spinner_core.js +++ b/tests/unit/spinner/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./spinner_test_helpers", + "./helper", "ui/spinner" ], function( $, testHelper ) { diff --git a/tests/unit/spinner/spinner_events.js b/tests/unit/spinner/events.js similarity index 99% rename from tests/unit/spinner/spinner_events.js rename to tests/unit/spinner/events.js index a37d6134620..a837f47c969 100644 --- a/tests/unit/spinner/spinner_events.js +++ b/tests/unit/spinner/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./spinner_test_helpers", + "./helper", "ui/spinner" ], function( $, testHelper ) { diff --git a/tests/unit/spinner/spinner_test_helpers.js b/tests/unit/spinner/helper.js similarity index 100% rename from tests/unit/spinner/spinner_test_helpers.js rename to tests/unit/spinner/helper.js diff --git a/tests/unit/spinner/spinner_methods.js b/tests/unit/spinner/methods.js similarity index 99% rename from tests/unit/spinner/spinner_methods.js rename to tests/unit/spinner/methods.js index 75ae5c9e83f..d6bf325f2fc 100644 --- a/tests/unit/spinner/spinner_methods.js +++ b/tests/unit/spinner/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./spinner_test_helpers", + "./helper", "ui/spinner" ], function( $, testHelper ) { diff --git a/tests/unit/spinner/spinner_options.js b/tests/unit/spinner/options.js similarity index 100% rename from tests/unit/spinner/spinner_options.js rename to tests/unit/spinner/options.js diff --git a/tests/unit/tabs/tabs_common.js b/tests/unit/tabs/common.js similarity index 100% rename from tests/unit/tabs/tabs_common.js rename to tests/unit/tabs/common.js diff --git a/tests/unit/tabs/tabs_core.js b/tests/unit/tabs/core.js similarity index 99% rename from tests/unit/tabs/tabs_core.js rename to tests/unit/tabs/core.js index 2e39ca0e6d5..82dc61a1fa9 100644 --- a/tests/unit/tabs/tabs_core.js +++ b/tests/unit/tabs/core.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./tabs_test_helpers", + "./helper", "ui/tabs" ], function( $, testHelper ) { diff --git a/tests/unit/tabs/tabs_events.js b/tests/unit/tabs/events.js similarity index 99% rename from tests/unit/tabs/tabs_events.js rename to tests/unit/tabs/events.js index fb274624828..ec2f61214b9 100644 --- a/tests/unit/tabs/tabs_events.js +++ b/tests/unit/tabs/events.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./tabs_test_helpers", + "./helper", "ui/tabs" ], function( $, testHelper ) { diff --git a/tests/unit/tabs/tabs_test_helpers.js b/tests/unit/tabs/helper.js similarity index 100% rename from tests/unit/tabs/tabs_test_helpers.js rename to tests/unit/tabs/helper.js diff --git a/tests/unit/tabs/tabs_methods.js b/tests/unit/tabs/methods.js similarity index 99% rename from tests/unit/tabs/tabs_methods.js rename to tests/unit/tabs/methods.js index fc1ff6dd6df..5975e588930 100644 --- a/tests/unit/tabs/tabs_methods.js +++ b/tests/unit/tabs/methods.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./tabs_test_helpers", + "./helper", "ui/tabs" ], function( $, testHelper ) { diff --git a/tests/unit/tabs/tabs_options.js b/tests/unit/tabs/options.js similarity index 99% rename from tests/unit/tabs/tabs_options.js rename to tests/unit/tabs/options.js index e4c3efa1542..e1a663a71a8 100644 --- a/tests/unit/tabs/tabs_options.js +++ b/tests/unit/tabs/options.js @@ -1,6 +1,6 @@ define( [ "jquery", - "./tabs_test_helpers", + "./helper", "ui/tabs" ], function( $, testHelper ) { diff --git a/tests/unit/tooltip/tooltip_common_deprecated.js b/tests/unit/tooltip/common-deprecated.js similarity index 100% rename from tests/unit/tooltip/tooltip_common_deprecated.js rename to tests/unit/tooltip/common-deprecated.js diff --git a/tests/unit/tooltip/tooltip_common.js b/tests/unit/tooltip/common.js similarity index 100% rename from tests/unit/tooltip/tooltip_common.js rename to tests/unit/tooltip/common.js diff --git a/tests/unit/tooltip/tooltip_core.js b/tests/unit/tooltip/core.js similarity index 100% rename from tests/unit/tooltip/tooltip_core.js rename to tests/unit/tooltip/core.js diff --git a/tests/unit/tooltip/tooltip_deprecated.html b/tests/unit/tooltip/deprecated.html similarity index 100% rename from tests/unit/tooltip/tooltip_deprecated.html rename to tests/unit/tooltip/deprecated.html diff --git a/tests/unit/tooltip/tooltip_deprecated.js b/tests/unit/tooltip/deprecated.js similarity index 100% rename from tests/unit/tooltip/tooltip_deprecated.js rename to tests/unit/tooltip/deprecated.js diff --git a/tests/unit/tooltip/tooltip_events.js b/tests/unit/tooltip/events.js similarity index 100% rename from tests/unit/tooltip/tooltip_events.js rename to tests/unit/tooltip/events.js diff --git a/tests/unit/tooltip/tooltip_methods.js b/tests/unit/tooltip/methods.js similarity index 100% rename from tests/unit/tooltip/tooltip_methods.js rename to tests/unit/tooltip/methods.js diff --git a/tests/unit/tooltip/tooltip_options.js b/tests/unit/tooltip/options.js similarity index 100% rename from tests/unit/tooltip/tooltip_options.js rename to tests/unit/tooltip/options.js diff --git a/tests/unit/widget/widget_animation.js b/tests/unit/widget/animation.js similarity index 100% rename from tests/unit/widget/widget_animation.js rename to tests/unit/widget/animation.js diff --git a/tests/unit/widget/widget_classes.js b/tests/unit/widget/classes.js similarity index 100% rename from tests/unit/widget/widget_classes.js rename to tests/unit/widget/classes.js diff --git a/tests/unit/widget/widget_core.js b/tests/unit/widget/core.js similarity index 100% rename from tests/unit/widget/widget_core.js rename to tests/unit/widget/core.js diff --git a/tests/unit/widget/widget_extend.js b/tests/unit/widget/extend.js similarity index 100% rename from tests/unit/widget/widget_extend.js rename to tests/unit/widget/extend.js diff --git a/tests/unit/widget/widget.html b/tests/unit/widget/widget.html index 8ccce85255e..0e9d500510c 100644 --- a/tests/unit/widget/widget.html +++ b/tests/unit/widget/widget.html @@ -5,13 +5,7 @@ jQuery UI Widget Test Suite - From 23a05f8ab0af59f4fb620172f02cd6e91900787a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Wed, 8 Apr 2015 09:15:23 -0400 Subject: [PATCH 28/29] Tests: Use the qunit-assert-close module Moved QUnit assertion dependencies from `lib/bootstrap` to `lib/qunit`. Corrected bad draggable assertions. --- Gruntfile.js | 3 + bower.json | 1 + external/qunit-assert-close/MIT-LICENSE.txt | 21 ++++ .../qunit-assert-close/qunit-assert-close.js | 106 ++++++++++++++++++ tests/lib/bootstrap.js | 10 +- tests/lib/qunit.js | 9 +- tests/unit/draggable/core.js | 6 +- 7 files changed, 141 insertions(+), 15 deletions(-) create mode 100644 external/qunit-assert-close/MIT-LICENSE.txt create mode 100644 external/qunit-assert-close/qunit-assert-close.js diff --git a/Gruntfile.js b/Gruntfile.js index b9a3a792b7a..f1fb6c5d7da 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -281,6 +281,9 @@ grunt.initConfig({ "qunit-assert-classes/qunit-assert-classes.js": "qunit-assert-classes/qunit-assert-classes.js", "qunit-assert-classes/LICENSE.txt": "qunit-assert-classes/LICENSE", + "qunit-assert-close/qunit-assert-close.js": "qunit-assert-close/qunit-assert-close.js", + "qunit-assert-close/MIT-LICENSE.txt": "qunit-assert-close/MIT-LICENSE.txt", + "qunit-composite/qunit-composite.js": "qunit-composite/qunit-composite.js", "qunit-composite/qunit-composite.css": "qunit-composite/qunit-composite.css", "qunit-composite/LICENSE.txt": "qunit-composite/LICENSE.txt", diff --git a/bower.json b/bower.json index e371c03c4b8..543a98db886 100644 --- a/bower.json +++ b/bower.json @@ -16,6 +16,7 @@ "jshint": "2.4.4", "qunit": "1.18.0", "qunit-assert-classes": "0.1.5", + "qunit-assert-close": "JamesMGreene/qunit-assert-close#v1.1.1", "qunit-composite": "JamesMGreene/qunit-composite#v1.0.4", "requirejs": "2.1.14", diff --git a/external/qunit-assert-close/MIT-LICENSE.txt b/external/qunit-assert-close/MIT-LICENSE.txt new file mode 100644 index 00000000000..aed5dc97ec5 --- /dev/null +++ b/external/qunit-assert-close/MIT-LICENSE.txt @@ -0,0 +1,21 @@ +Copyright jQuery Foundation and other contributors +http://jquery.com/ + +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. diff --git a/external/qunit-assert-close/qunit-assert-close.js b/external/qunit-assert-close/qunit-assert-close.js new file mode 100644 index 00000000000..bd843810a52 --- /dev/null +++ b/external/qunit-assert-close/qunit-assert-close.js @@ -0,0 +1,106 @@ +/** + * Checks that the first two arguments are equal, or are numbers close enough to be considered equal + * based on a specified maximum allowable difference. + * + * @example assert.close(3.141, Math.PI, 0.001); + * + * @param Number actual + * @param Number expected + * @param Number maxDifference (the maximum inclusive difference allowed between the actual and expected numbers) + * @param String message (optional) + */ +function close(actual, expected, maxDifference, message) { + var actualDiff = (actual === expected) ? 0 : Math.abs(actual - expected), + result = actualDiff <= maxDifference; + message = message || (actual + " should be within " + maxDifference + " (inclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff)); + QUnit.push(result, actual, expected, message); +} + + +/** + * Checks that the first two arguments are equal, or are numbers close enough to be considered equal + * based on a specified maximum allowable difference percentage. + * + * @example assert.close.percent(155, 150, 3.4); // Difference is ~3.33% + * + * @param Number actual + * @param Number expected + * @param Number maxPercentDifference (the maximum inclusive difference percentage allowed between the actual and expected numbers) + * @param String message (optional) + */ +close.percent = function closePercent(actual, expected, maxPercentDifference, message) { + var actualDiff, result; + if (actual === expected) { + actualDiff = 0; + result = actualDiff <= maxPercentDifference; + } + else if (actual !== 0 && expected !== 0 && expected !== Infinity && expected !== -Infinity) { + actualDiff = Math.abs(100 * (actual - expected) / expected); + result = actualDiff <= maxPercentDifference; + } + else { + // Dividing by zero (0)! Should return `false` unless the max percentage was `Infinity` + actualDiff = Infinity; + result = maxPercentDifference === Infinity; + } + message = message || (actual + " should be within " + maxPercentDifference + "% (inclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff + "%")); + + QUnit.push(result, actual, expected, message); +}; + + +/** + * Checks that the first two arguments are numbers with differences greater than the specified + * minimum difference. + * + * @example assert.notClose(3.1, Math.PI, 0.001); + * + * @param Number actual + * @param Number expected + * @param Number minDifference (the minimum exclusive difference allowed between the actual and expected numbers) + * @param String message (optional) + */ +function notClose(actual, expected, minDifference, message) { + var actualDiff = Math.abs(actual - expected), + result = actualDiff > minDifference; + message = message || (actual + " should not be within " + minDifference + " (exclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff)); + QUnit.push(result, actual, expected, message); +} + + +/** + * Checks that the first two arguments are numbers with differences greater than the specified + * minimum difference percentage. + * + * @example assert.notClose.percent(156, 150, 3.5); // Difference is 4.0% + * + * @param Number actual + * @param Number expected + * @param Number minPercentDifference (the minimum exclusive difference percentage allowed between the actual and expected numbers) + * @param String message (optional) + */ +notClose.percent = function notClosePercent(actual, expected, minPercentDifference, message) { + var actualDiff, result; + if (actual === expected) { + actualDiff = 0; + result = actualDiff > minPercentDifference; + } + else if (actual !== 0 && expected !== 0 && expected !== Infinity && expected !== -Infinity) { + actualDiff = Math.abs(100 * (actual - expected) / expected); + result = actualDiff > minPercentDifference; + } + else { + // Dividing by zero (0)! Should only return `true` if the min percentage was `Infinity` + actualDiff = Infinity; + result = minPercentDifference !== Infinity; + } + message = message || (actual + " should not be within " + minPercentDifference + "% (exclusive) of " + expected + (result ? "" : ". Actual: " + actualDiff + "%")); + + QUnit.push(result, actual, expected, message); +}; + + +QUnit.extend(QUnit.assert, { + close: close, + notClose: notClose +}); \ No newline at end of file diff --git a/tests/lib/bootstrap.js b/tests/lib/bootstrap.js index 6d608f2ebf2..7ca1bbda749 100644 --- a/tests/lib/bootstrap.js +++ b/tests/lib/bootstrap.js @@ -10,13 +10,15 @@ window.requirejs = { "lib": "../../lib", "phantom-bridge": "../../../node_modules/grunt-contrib-qunit/phantomjs/bridge", "qunit-assert-classes": "../../../external/qunit-assert-classes/qunit-assert-classes", + "qunit-assert-close": "../../../external/qunit-assert-close/qunit-assert-close", "qunit": "../../../external/qunit/qunit", "ui": "../../../ui" }, shim: { "globalize/ja-JP": [ "globalize" ], "jquery-simulate": [ "jquery" ], - "qunit-assert-classes": [ "qunit" ] + "qunit-assert-classes": [ "qunit" ], + "qunit-assert-close": [ "qunit" ] } }; @@ -43,11 +45,9 @@ function requireModules( dependencies, callback, modules ) { // Load a set of test file along with the required test infrastructure function requireTests( dependencies, noBackCompat ) { dependencies = [ - "../../lib/qunit", + "lib/qunit", noBackCompat ? "jquery-no-back-compat" : "jquery", - "jquery-simulate", - "qunit-assert-classes", - "../../lib/qunit-assert-domequal" + "jquery-simulate" ].concat( dependencies ); requireModules( dependencies, function( QUnit ) { diff --git a/tests/lib/qunit.js b/tests/lib/qunit.js index 5b0be5d2393..757b6a501ec 100644 --- a/tests/lib/qunit.js +++ b/tests/lib/qunit.js @@ -1,6 +1,9 @@ define( [ "qunit", "jquery", + "qunit-assert-classes", + "qunit-assert-close", + "lib/qunit-assert-domequal", "phantom-bridge" ], function( QUnit, $ ) { @@ -40,12 +43,6 @@ QUnit.reset = ( function( reset ) { }; } )( QUnit.reset ); -// TODO: switch to qunit-assert-close plugin -QUnit.assert.close = function( actual, expected, maxDifference, message ) { - var passes = ( actual === expected ) || Math.abs( actual - expected ) <= maxDifference; - QUnit.push( passes, actual, expected, message ); -}; - return QUnit; } ); diff --git a/tests/unit/draggable/core.js b/tests/unit/draggable/core.js index ef55026ee10..9e8a665bc4b 100644 --- a/tests/unit/draggable/core.js +++ b/tests/unit/draggable/core.js @@ -366,13 +366,11 @@ test( "setting right/bottom css shouldn't cause resize", function( assert ) { testHelper.move( element, -50, -50 ); finalOffset = element.offset(); - finalOffset.left += 50; - finalOffset.top += 50; assert.close( element.width(), origWidth, 1, "element retains width" ); assert.close( element.height(), origHeight, 1, "element retains height" ); - assert.close( finalOffset.top, origOffset.top, "element moves the correct vertical distance" ); - assert.close( finalOffset.top, origOffset.top, "element moves the correct horizontal distance" ); + assert.close( finalOffset.top, origOffset.top - 50, 1, "element moves the correct vertical distance" ); + assert.close( finalOffset.top, origOffset.top - 50, 1, "element moves the correct horizontal distance" ); }); } ); From 426408cec78197cadb9a392303d6f36686aafc96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Scott=20Gonz=C3=A1lez?= Date: Thu, 9 Apr 2015 09:11:34 -0400 Subject: [PATCH 29/29] Build: Upgrade to qunit-composite 1.1.0 --- bower.json | 2 +- external/qunit-composite/qunit-composite.js | 17 ++++++++++++++--- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/bower.json b/bower.json index 543a98db886..b5b8e4420d0 100644 --- a/bower.json +++ b/bower.json @@ -17,7 +17,7 @@ "qunit": "1.18.0", "qunit-assert-classes": "0.1.5", "qunit-assert-close": "JamesMGreene/qunit-assert-close#v1.1.1", - "qunit-composite": "JamesMGreene/qunit-composite#v1.0.4", + "qunit-composite": "JamesMGreene/qunit-composite#v1.1.0", "requirejs": "2.1.14", "jquery-1.7.0": "jquery#1.7.0", diff --git a/external/qunit-composite/qunit-composite.js b/external/qunit-composite/qunit-composite.js index 6cff04b5132..1ffd2eea575 100644 --- a/external/qunit-composite/qunit-composite.js +++ b/external/qunit-composite/qunit-composite.js @@ -1,5 +1,5 @@ /** - * QUnit Composite v1.0.4 + * QUnit Composite v1.0.5-pre * * https://github.com/JamesMGreene/qunit-composite * @@ -7,7 +7,13 @@ * Released under the MIT license. * https://jquery.org/license/ */ -(function( QUnit ) { +(function( factory ) { + if ( typeof define === "function" && define.amd ) { + define( [ "qunit" ], factory ); + } else { + factory( QUnit ); + } +}(function( QUnit ) { var iframe, hasBound, modules = 1, executingComposite = false; @@ -60,6 +66,11 @@ function initIframe() { return; } + // Deal with QUnit being loaded asynchronously via AMD + if ( !iframeWin.QUnit && iframeWin.define && iframeWin.define.amd ) { + return iframeWin.require( [ "qunit" ], onIframeLoad ); + } + iframeWin.QUnit.moduleStart(function( data ) { // Capture module name for messages moduleName = data.name; @@ -181,4 +192,4 @@ QUnit.testDone(function( data ) { current.getElementsByTagName( "a" )[ 0 ].href = src; }); -})( QUnit ); +}));