dist/ember-testing.js in ember-source-1.11.3 vs dist/ember-testing.js in ember-source-1.11.3.1
- old
+ new
@@ -107,47 +107,40 @@
'use strict';
exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags;
- /**
- Will call `Ember.warn()` if ENABLE_ALL_FEATURES, ENABLE_OPTIONAL_FEATURES, or
- any specific FEATURES flag is truthy.
+ /*global __fail__*/
- This method is called automatically in debug canary builds.
-
- @private
- @method _warnIfUsingStrippedFeatureFlags
- @return {void}
- */
- Ember['default'].assert = function (desc, test) {
+ Ember['default'].assert = function(desc, test) {
var throwAssertion;
- if (Ember['default'].typeOf(test) === "function") {
+ if (Ember['default'].typeOf(test) === 'function') {
throwAssertion = !test();
} else {
throwAssertion = !test;
}
if (throwAssertion) {
throw new EmberError['default']("Assertion Failed: " + desc);
}
};
+
/**
Display a warning with the provided message. Ember build tools will
remove any calls to `Ember.warn()` when doing a production build.
@method warn
@param {String} message A warning to display.
@param {Boolean} test An optional boolean. If falsy, the warning
will be displayed.
*/
- Ember['default'].warn = function (message, test) {
+ Ember['default'].warn = function(message, test) {
if (!test) {
- Logger['default'].warn("WARNING: " + message);
- if ("trace" in Logger['default']) {
+ Logger['default'].warn("WARNING: "+message);
+ if ('trace' in Logger['default']) {
Logger['default'].trace();
}
}
};
@@ -160,12 +153,12 @@
```
@method debug
@param {String} message A debug message to display.
*/
- Ember['default'].debug = function (message) {
- Logger['default'].debug("DEBUG: " + message);
+ Ember['default'].debug = function(message) {
+ Logger['default'].debug("DEBUG: "+message);
};
/**
Display a deprecation warning with the provided message and a stack trace
(Chrome and Firefox only). Ember build tools will remove any calls to
@@ -176,63 +169,60 @@
@param {Boolean} test An optional boolean. If falsy, the deprecation
will be displayed.
@param {Object} options An optional object that can be used to pass
in a `url` to the transition guide on the emberjs.com website.
*/
- Ember['default'].deprecate = function (message, test, options) {
+ Ember['default'].deprecate = function(message, test, options) {
var noDeprecation;
- if (typeof test === "function") {
+ if (typeof test === 'function') {
noDeprecation = test();
} else {
noDeprecation = test;
}
- if (noDeprecation) {
- return;
- }
+ if (noDeprecation) { return; }
- if (Ember['default'].ENV.RAISE_ON_DEPRECATION) {
- throw new EmberError['default'](message);
- }
+ if (Ember['default'].ENV.RAISE_ON_DEPRECATION) { throw new EmberError['default'](message); }
var error;
// When using new Error, we can't do the arguments check for Chrome. Alternatives are welcome
- try {
- __fail__.fail();
- } catch (e) {
- error = e;
- }
+ try { __fail__.fail(); } catch (e) { error = e; }
if (arguments.length === 3) {
- Ember['default'].assert("options argument to Ember.deprecate should be an object", options && typeof options === "object");
+ Ember['default'].assert('options argument to Ember.deprecate should be an object', options && typeof options === 'object');
if (options.url) {
- message += " See " + options.url + " for more details.";
+ message += ' See ' + options.url + ' for more details.';
}
}
if (Ember['default'].LOG_STACKTRACE_ON_DEPRECATION && error.stack) {
var stack;
- var stackStr = "";
+ var stackStr = '';
- if (error["arguments"]) {
+ if (error['arguments']) {
// Chrome
- stack = error.stack.replace(/^\s+at\s+/gm, "").replace(/^([^\(]+?)([\n$])/gm, "{anonymous}($1)$2").replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, "{anonymous}($1)").split("\n");
+ stack = error.stack.replace(/^\s+at\s+/gm, '').
+ replace(/^([^\(]+?)([\n$])/gm, '{anonymous}($1)$2').
+ replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}($1)').split('\n');
stack.shift();
} else {
// Firefox
- stack = error.stack.replace(/(?:\n@:0)?\s+$/m, "").replace(/^\(/gm, "{anonymous}(").split("\n");
+ stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').
+ replace(/^\(/gm, '{anonymous}(').split('\n');
}
stackStr = "\n " + stack.slice(2).join("\n ");
message = message + stackStr;
}
- Logger['default'].warn("DEPRECATION: " + message);
+ Logger['default'].warn("DEPRECATION: "+message);
};
+
+
/**
Alias an old, deprecated method with its new counterpart.
Display a deprecation warning with the provided message and a stack trace
(Chrome and Firefox only) when the assigned method is called.
@@ -247,17 +237,18 @@
@method deprecateFunc
@param {String} message A description of the deprecation.
@param {Function} func The new function called to replace its deprecated counterpart.
@return {Function} a new function that wrapped the original function with a deprecation warning
*/
- Ember['default'].deprecateFunc = function (message, func) {
- return function () {
+ Ember['default'].deprecateFunc = function(message, func) {
+ return function() {
Ember['default'].deprecate(message);
return func.apply(this, arguments);
};
};
+
/**
Run a function meant for debugging. Ember build tools will remove any calls to
`Ember.runInDebug()` when doing a production build.
```javascript
@@ -272,51 +263,62 @@
@method runInDebug
@param {Function} func The function to be executed.
@since 1.5.0
*/
- Ember['default'].runInDebug = function (func) {
+ Ember['default'].runInDebug = function(func) {
func();
};
+
+ /**
+ Will call `Ember.warn()` if ENABLE_ALL_FEATURES, ENABLE_OPTIONAL_FEATURES, or
+ any specific FEATURES flag is truthy.
+
+ This method is called automatically in debug canary builds.
+
+ @private
+ @method _warnIfUsingStrippedFeatureFlags
+ @return {void}
+ */
function _warnIfUsingStrippedFeatureFlags(FEATURES, featuresWereStripped) {
if (featuresWereStripped) {
- Ember['default'].warn("Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.", !Ember['default'].ENV.ENABLE_ALL_FEATURES);
- Ember['default'].warn("Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.", !Ember['default'].ENV.ENABLE_OPTIONAL_FEATURES);
+ Ember['default'].warn('Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_ALL_FEATURES);
+ Ember['default'].warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !Ember['default'].ENV.ENABLE_OPTIONAL_FEATURES);
for (var key in FEATURES) {
- if (FEATURES.hasOwnProperty(key) && key !== "isEnabled") {
- Ember['default'].warn("FEATURE[\"" + key + "\"] is set as enabled, but FEATURE flags are only available in canary builds.", !FEATURES[key]);
+ if (FEATURES.hasOwnProperty(key) && key !== 'isEnabled') {
+ Ember['default'].warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key]);
}
}
}
}
if (!Ember['default'].testing) {
// Complain if they're using FEATURE flags in builds other than canary
- Ember['default'].FEATURES["features-stripped-test"] = true;
+ Ember['default'].FEATURES['features-stripped-test'] = true;
var featuresWereStripped = true;
- delete Ember['default'].FEATURES["features-stripped-test"];
+ delete Ember['default'].FEATURES['features-stripped-test'];
_warnIfUsingStrippedFeatureFlags(Ember['default'].ENV.FEATURES, featuresWereStripped);
// Inform the developer about the Ember Inspector if not installed.
- var isFirefox = typeof InstallTrigger !== "undefined";
+ var isFirefox = typeof InstallTrigger !== 'undefined';
var isChrome = environment['default'].isChrome;
- if (typeof window !== "undefined" && (isFirefox || isChrome) && window.addEventListener) {
- window.addEventListener("load", function () {
+ if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+ window.addEventListener("load", function() {
if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset.emberExtension) {
var downloadURL;
if (isChrome) {
- downloadURL = "https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi";
+ downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
} else if (isFirefox) {
- downloadURL = "https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/";
+ downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
}
- Ember['default'].debug("For more advanced debugging, install the Ember Inspector from " + downloadURL);
+ Ember['default'].debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
}
}, false);
}
}
@@ -328,11 +330,11 @@
so that if `ember.js` (which must be output for backwards compat reasons) is
used a nice helpful warning message will be printed out.
*/
var runningNonEmberDebugJS = false;
if (runningNonEmberDebugJS) {
- Ember['default'].warn("Please use `ember.debug.js` instead of `ember.js` for development and debugging.");
+ Ember['default'].warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.');
}
exports.runningNonEmberDebugJS = runningNonEmberDebugJS;
});
@@ -348,13 +350,11 @@
});
enifed('ember-testing/adapters/adapter', ['exports', 'ember-runtime/system/object'], function (exports, EmberObject) {
'use strict';
- function K() {
- return this;
- }
+ function K() { return this; }
/**
@module ember
@submodule ember-testing
*/
@@ -367,39 +367,45 @@
@namespace Ember.Test
*/
var Adapter = EmberObject['default'].extend({
/**
This callback will be called whenever an async operation is about to start.
- Override this to call your framework's methods that handle async
+
+ Override this to call your framework's methods that handle async
operations.
- @public
+
+ @public
@method asyncStart
*/
asyncStart: K,
/**
This callback will be called whenever an async operation has completed.
- @public
+
+ @public
@method asyncEnd
*/
asyncEnd: K,
/**
Override this method with your testing framework's false assertion.
This function is called whenever an exception occurs causing the testing
promise to fail.
- QUnit example:
- ```javascript
+
+ QUnit example:
+
+ ```javascript
exception: function(error) {
ok(false, error);
};
```
- @public
+
+ @public
@method exception
@param {String} error The exception to be raised.
*/
- exception: function (error) {
+ exception: function(error) {
throw error;
}
});
exports['default'] = Adapter;
@@ -408,17 +414,17 @@
enifed('ember-testing/adapters/qunit', ['exports', 'ember-testing/adapters/adapter', 'ember-metal/utils'], function (exports, Adapter, utils) {
'use strict';
exports['default'] = Adapter['default'].extend({
- asyncStart: function () {
+ asyncStart: function() {
QUnit.stop();
},
- asyncEnd: function () {
+ asyncEnd: function() {
QUnit.start();
},
- exception: function (error) {
+ exception: function(error) {
ok(false, utils.inspect(error));
}
});
});
@@ -428,97 +434,99 @@
var helper = Test['default'].registerHelper;
var asyncHelper = Test['default'].registerAsyncHelper;
function currentRouteName(app) {
- var appController = app.__container__.lookup("controller:application");
+ var appController = app.__container__.lookup('controller:application');
- return property_get.get(appController, "currentRouteName");
+ return property_get.get(appController, 'currentRouteName');
}
function currentPath(app) {
- var appController = app.__container__.lookup("controller:application");
+ var appController = app.__container__.lookup('controller:application');
- return property_get.get(appController, "currentPath");
+ return property_get.get(appController, 'currentPath');
}
function currentURL(app) {
- var router = app.__container__.lookup("router:main");
+ var router = app.__container__.lookup('router:main');
- return property_get.get(router, "location").getURL();
+ return property_get.get(router, 'location').getURL();
}
function pauseTest() {
Test['default'].adapter.asyncStart();
- return new Ember['default'].RSVP.Promise(function () {}, "TestAdapter paused promise");
+ return new Ember['default'].RSVP.Promise(function() { }, 'TestAdapter paused promise');
}
function focus(el) {
- if (el && el.is(":input, [contenteditable=true]")) {
- var type = el.prop("type");
- if (type !== "checkbox" && type !== "radio" && type !== "hidden") {
- run['default'](el, function () {
+ if (el && el.is(':input, [contenteditable=true]')) {
+ var type = el.prop('type');
+ if (type !== 'checkbox' && type !== 'radio' && type !== 'hidden') {
+ run['default'](el, function() {
// Firefox does not trigger the `focusin` event if the window
// does not have focus. If the document doesn't have focus just
// use trigger('focusin') instead.
if (!document.hasFocus || document.hasFocus()) {
this.focus();
} else {
- this.trigger("focusin");
+ this.trigger('focusin');
}
});
}
}
}
function visit(app, url) {
- var router = app.__container__.lookup("router:main");
+ var router = app.__container__.lookup('router:main');
router.location.setURL(url);
if (app._readinessDeferrals > 0) {
- router["initialURL"] = url;
- run['default'](app, "advanceReadiness");
- delete router["initialURL"];
+ router['initialURL'] = url;
+ run['default'](app, 'advanceReadiness');
+ delete router['initialURL'];
} else {
- run['default'](app.__deprecatedInstance__, "handleURL", url);
+ run['default'](app.__deprecatedInstance__, 'handleURL', url);
}
return app.testHelpers.wait();
}
function click(app, selector, context) {
var $el = app.testHelpers.findWithAssert(selector, context);
- run['default']($el, "mousedown");
+ run['default']($el, 'mousedown');
focus($el);
- run['default']($el, "mouseup");
- run['default']($el, "click");
+ run['default']($el, 'mouseup');
+ run['default']($el, 'click');
return app.testHelpers.wait();
}
function check(app, selector, context) {
var $el = app.testHelpers.findWithAssert(selector, context);
- var type = $el.prop("type");
+ var type = $el.prop('type');
- Ember['default'].assert("To check '" + selector + "', the input must be a checkbox", type === "checkbox");
+ Ember['default'].assert('To check \'' + selector +
+ '\', the input must be a checkbox', type === 'checkbox');
- if (!$el.prop("checked")) {
+ if (!$el.prop('checked')) {
app.testHelpers.click(selector, context);
}
return app.testHelpers.wait();
}
function uncheck(app, selector, context) {
var $el = app.testHelpers.findWithAssert(selector, context);
- var type = $el.prop("type");
+ var type = $el.prop('type');
- Ember['default'].assert("To uncheck '" + selector + "', the input must be a checkbox", type === "checkbox");
+ Ember['default'].assert('To uncheck \'' + selector +
+ '\', the input must be a checkbox', type === 'checkbox');
- if ($el.prop("checked")) {
+ if ($el.prop('checked')) {
app.testHelpers.click(selector, context);
}
return app.testHelpers.wait();
}
@@ -533,18 +541,16 @@
context = null;
type = contextOrType;
options = {};
} else if (arity === 4) {
// context and options are optional, so this is
- if (typeof typeOrOptions === "object") {
- // either
+ if (typeof typeOrOptions === "object") { // either
// app, selector, type, options
context = null;
type = contextOrType;
options = typeOrOptions;
- } else {
- // or
+ } else { // or
// app, selector, context, type
context = contextOrType;
type = typeOrOptions;
options = {};
}
@@ -556,19 +562,19 @@
var $el = app.testHelpers.findWithAssert(selector, context);
var event = jQuery['default'].Event(type, options);
- run['default']($el, "trigger", event);
+ run['default']($el, 'trigger', event);
return app.testHelpers.wait();
}
function keyEvent(app, selector, contextOrType, typeOrKeyCode, keyCode) {
var context, type;
- if (typeof keyCode === "undefined") {
+ if (typeof keyCode === 'undefined') {
context = null;
keyCode = typeOrKeyCode;
type = contextOrType;
} else {
context = contextOrType;
@@ -578,18 +584,18 @@
return app.testHelpers.triggerEvent(selector, context, type, { keyCode: keyCode, which: keyCode });
}
function fillIn(app, selector, contextOrText, text) {
var $el, context;
- if (typeof text === "undefined") {
+ if (typeof text === 'undefined') {
text = contextOrText;
} else {
context = contextOrText;
}
$el = app.testHelpers.findWithAssert(selector, context);
focus($el);
- run['default'](function () {
+ run['default'](function() {
$el.val(text).change();
});
return app.testHelpers.wait();
}
@@ -601,42 +607,36 @@
return $el;
}
function find(app, selector, context) {
var $el;
- context = context || property_get.get(app, "rootElement");
+ context = context || property_get.get(app, 'rootElement');
$el = app.$(selector, context);
return $el;
}
function andThen(app, callback) {
return app.testHelpers.wait(callback(app));
}
function wait(app, value) {
- return new RSVP['default'].Promise(function (resolve) {
+ return new RSVP['default'].Promise(function(resolve) {
// Every 10ms, poll for the async thing to have finished
- var watcher = setInterval(function () {
- var router = app.__container__.lookup("router:main");
+ var watcher = setInterval(function() {
+ var router = app.__container__.lookup('router:main');
// 1. If the router is loading, keep polling
var routerIsLoading = router.router && !!router.router.activeTransition;
- if (routerIsLoading) {
- return;
- }
+ if (routerIsLoading) { return; }
// 2. If there are pending Ajax requests, keep polling
- if (Test['default'].pendingAjaxRequests) {
- return;
- }
+ if (Test['default'].pendingAjaxRequests) { return; }
// 3. If there are scheduled timers or we are inside of a run loop, keep polling
- if (run['default'].hasScheduledTimers() || run['default'].currentRunLoop) {
- return;
- }
- if (Test['default'].waiters && Test['default'].waiters.any(function (waiter) {
+ if (run['default'].hasScheduledTimers() || run['default'].currentRunLoop) { return; }
+ if (Test['default'].waiters && Test['default'].waiters.any(function(waiter) {
var context = waiter[0];
var callback = waiter[1];
return !callback.call(context);
})) {
return;
@@ -646,12 +646,14 @@
// Synchronously resolve the promise
run['default'](null, resolve, value);
}, 10);
});
+
}
+
/**
* Loads a route, sets up any controllers, and renders any templates associated
* with the route as though a real user had triggered the route change while
* using your app.
*
@@ -665,11 +667,11 @@
*
* @method visit
* @param {String} url the name of the route
* @return {RSVP.Promise}
*/
- asyncHelper("visit", visit);
+ asyncHelper('visit', visit);
/**
* Clicks an element and triggers any actions triggered by the element's `click`
* event.
*
@@ -683,11 +685,11 @@
*
* @method click
* @param {String} selector jQuery selector for finding element on the DOM
* @return {RSVP.Promise}
*/
- asyncHelper("click", click);
+ asyncHelper('click', click);
/**
* Simulates a key event, e.g. `keypress`, `keydown`, `keyup` with the desired keyCode
*
* Example:
@@ -703,11 +705,11 @@
* @param {String} type the type of key event, e.g. `keypress`, `keydown`, `keyup`
* @param {Number} keyCode the keyCode of the simulated key event
* @return {RSVP.Promise}
* @since 1.5.0
*/
- asyncHelper("keyEvent", keyEvent);
+ asyncHelper('keyEvent', keyEvent);
/**
* Fills in an input element with some text.
*
* Example:
@@ -722,11 +724,11 @@
* @param {String} selector jQuery selector finding an input element on the DOM
* to fill text with
* @param {String} text text to place inside the input element
* @return {RSVP.Promise}
*/
- asyncHelper("fillIn", fillIn);
+ asyncHelper('fillIn', fillIn);
/**
* Finds an element in the context of the app's container element. A simple alias
* for `app.$(selector)`.
*
@@ -738,11 +740,11 @@
*
* @method find
* @param {String} selector jQuery string selector for element lookup
* @return {Object} jQuery object representing the results of the query
*/
- helper("find", find);
+ helper('find', find);
/**
* Like `find`, but throws an error if the element selector returns no results.
*
* Example:
@@ -755,11 +757,11 @@
* @param {String} selector jQuery selector string for finding an element within
* the DOM
* @return {Object} jQuery object representing the results of the query
* @throws {Error} throws error if jQuery object returned has a length of 0
*/
- helper("findWithAssert", findWithAssert);
+ helper('findWithAssert', findWithAssert);
/**
Causes the run loop to process any pending events. This is used to ensure that
any async operations from other helpers (or your assertions) have been processed.
@@ -780,13 +782,14 @@
@method wait
@param {Object} value The value to be returned.
@return {RSVP.Promise}
*/
- asyncHelper("wait", wait);
- asyncHelper("andThen", andThen);
+ asyncHelper('wait', wait);
+ asyncHelper('andThen', andThen);
+
/**
Returns the currently active route name.
Example:
@@ -800,11 +803,11 @@
@method currentRouteName
@return {Object} The name of the currently active route.
@since 1.5.0
*/
- helper("currentRouteName", currentRouteName);
+ helper('currentRouteName', currentRouteName);
/**
Returns the current path.
Example:
@@ -819,11 +822,11 @@
@method currentPath
@return {Object} The currently active path.
@since 1.5.0
*/
- helper("currentPath", currentPath);
+ helper('currentPath', currentPath);
/**
Returns the current URL.
Example:
@@ -838,11 +841,11 @@
@method currentURL
@return {Object} The currently active URL.
@since 1.5.0
*/
- helper("currentURL", currentURL);
+ helper('currentURL', currentURL);
/**
Pauses the current test - this is useful for debugging while testing or for test-driving.
It allows you to inspect the state of your application at any point.
@@ -857,11 +860,11 @@
@since 1.9.0
@method pauseTest
@return {Object} A promise that will never resolve
*/
- helper("pauseTest", pauseTest);
+ helper('pauseTest', pauseTest);
/**
Triggers the given DOM event on the element identified by the provided selector.
Example:
@@ -883,25 +886,25 @@
@param {String} type The event type to be triggered.
@param {Object} [options] The options to be passed to jQuery.Event.
@return {RSVP.Promise}
@since 1.5.0
*/
- asyncHelper("triggerEvent", triggerEvent);
+ asyncHelper('triggerEvent', triggerEvent);
});
enifed('ember-testing/initializers', ['ember-runtime/system/lazy_load'], function (lazy_load) {
'use strict';
- var name = "deferReadiness in `testing` mode";
+ var name = 'deferReadiness in `testing` mode';
- lazy_load.onLoad("Ember.Application", function (Application) {
+ lazy_load.onLoad('Ember.Application', function(Application) {
if (!Application.initializers[name]) {
Application.initializer({
name: name,
- initialize: function (registry, application) {
+ initialize: function(registry, application) {
if (application.testing) {
application.deferReadiness();
}
}
});
@@ -911,43 +914,39 @@
});
enifed('ember-testing/setup_for_testing', ['exports', 'ember-metal/core', 'ember-testing/adapters/qunit', 'ember-views/system/jquery'], function (exports, Ember, QUnitAdapter, jQuery) {
'use strict';
-
-
- /**
- Sets Ember up for testing. This is useful to perform
- basic setup steps in order to unit test.
-
- Use `App.setupForTesting` to perform integration tests (full
- application testing).
-
- @method setupForTesting
- @namespace Ember
- @since 1.5.0
- */
- exports['default'] = setupForTesting;
var Test, requests;
function incrementAjaxPendingRequests(_, xhr) {
requests.push(xhr);
Test.pendingAjaxRequests = requests.length;
}
function decrementAjaxPendingRequests(_, xhr) {
- for (var i = 0; i < requests.length; i++) {
+ for (var i=0;i<requests.length;i++) {
if (xhr === requests[i]) {
requests.splice(i, 1);
}
}
Test.pendingAjaxRequests = requests.length;
}
+
+ /**
+ Sets Ember up for testing. This is useful to perform
+ basic setup steps in order to unit test.
+
+ Use `App.setupForTesting` to perform integration tests (full
+ application testing).
+
+ @method setupForTesting
+ @namespace Ember
+ @since 1.5.0
+ */
function setupForTesting() {
- if (!Test) {
- Test = requireModule("ember-testing/test")["default"];
- }
+ if (!Test) { Test = requireModule('ember-testing/test')['default']; }
Ember['default'].testing = true;
// if adapter is not manually set default to QUnit
if (!Test.adapter) {
@@ -955,15 +954,16 @@
}
requests = [];
Test.pendingAjaxRequests = requests.length;
- jQuery['default'](document).off("ajaxSend", incrementAjaxPendingRequests);
- jQuery['default'](document).off("ajaxComplete", decrementAjaxPendingRequests);
- jQuery['default'](document).on("ajaxSend", incrementAjaxPendingRequests);
- jQuery['default'](document).on("ajaxComplete", decrementAjaxPendingRequests);
+ jQuery['default'](document).off('ajaxSend', incrementAjaxPendingRequests);
+ jQuery['default'](document).off('ajaxComplete', decrementAjaxPendingRequests);
+ jQuery['default'](document).on('ajaxSend', incrementAjaxPendingRequests);
+ jQuery['default'](document).on('ajaxComplete', decrementAjaxPendingRequests);
}
+ exports['default'] = setupForTesting;
});
enifed('ember-testing/support', ['ember-metal/core', 'ember-views/system/jquery', 'ember-metal/environment'], function (Ember, jQuery, environment) {
'use strict';
@@ -977,38 +977,44 @@
@private
@method testCheckboxClick
*/
function testCheckboxClick(handler) {
- $("<input type=\"checkbox\">").css({ position: "absolute", left: "-1000px", top: "-1000px" }).appendTo("body").on("click", handler).trigger("click").remove();
+ $('<input type="checkbox">')
+ .css({ position: 'absolute', left: '-1000px', top: '-1000px' })
+ .appendTo('body')
+ .on('click', handler)
+ .trigger('click')
+ .remove();
}
if (environment['default'].hasDOM) {
- $(function () {
+ $(function() {
/*
Determine whether a checkbox checked using jQuery's "click" method will have
the correct value for its checked property.
- If we determine that the current jQuery version exhibits this behavior,
+
+ If we determine that the current jQuery version exhibits this behavior,
patch it to work correctly as in the commit for the actual fix:
https://github.com/jquery/jquery/commit/1fb2f92.
*/
- testCheckboxClick(function () {
+ testCheckboxClick(function() {
if (!this.checked && !$.event.special.click) {
$.event.special.click = {
// For checkbox, fire native event so checked state will be right
- trigger: function () {
+ trigger: function() {
if ($.nodeName(this, "input") && this.type === "checkbox" && this.click) {
this.click();
return false;
}
}
};
}
});
// Try again to verify that the patch took effect or blow up.
- testCheckboxClick(function () {
+ testCheckboxClick(function() {
Ember['default'].warn("clicked checkboxes should be checked! the jQuery patch didn't work", this.checked);
});
});
}
@@ -1033,190 +1039,227 @@
@namespace Ember
*/
var Test = {
/**
Hash containing all known test helpers.
- @property _helpers
+
+ @property _helpers
@private
@since 1.7.0
*/
_helpers: helpers,
/**
`registerHelper` is used to register a test helper that will be injected
when `App.injectTestHelpers` is called.
- The helper method will always be called with the current Application as
+
+ The helper method will always be called with the current Application as
the first parameter.
- For example:
- ```javascript
+
+ For example:
+
+ ```javascript
Ember.Test.registerHelper('boot', function(app) {
Ember.run(app, app.advanceReadiness);
});
```
- This helper can later be called without arguments because it will be
+
+ This helper can later be called without arguments because it will be
called with `app` as the first parameter.
- ```javascript
+
+ ```javascript
App = Ember.Application.create();
App.injectTestHelpers();
boot();
```
- @public
+
+ @public
@method registerHelper
@param {String} name The name of the helper method to add.
@param {Function} helperMethod
@param options {Object}
*/
- registerHelper: function (name, helperMethod) {
+ registerHelper: function(name, helperMethod) {
helpers[name] = {
method: helperMethod,
meta: { wait: false }
};
},
/**
`registerAsyncHelper` is used to register an async test helper that will be injected
when `App.injectTestHelpers` is called.
- The helper method will always be called with the current Application as
+
+ The helper method will always be called with the current Application as
the first parameter.
- For example:
- ```javascript
+
+ For example:
+
+ ```javascript
Ember.Test.registerAsyncHelper('boot', function(app) {
Ember.run(app, app.advanceReadiness);
});
```
- The advantage of an async helper is that it will not run
+
+ The advantage of an async helper is that it will not run
until the last async helper has completed. All async helpers
after it will wait for it complete before running.
- For example:
- ```javascript
+
+
+ For example:
+
+ ```javascript
Ember.Test.registerAsyncHelper('deletePost', function(app, postId) {
click('.delete-' + postId);
});
- // ... in your test
+
+ // ... in your test
visit('/post/2');
deletePost(2);
visit('/post/3');
deletePost(3);
```
- @public
+
+ @public
@method registerAsyncHelper
@param {String} name The name of the helper method to add.
@param {Function} helperMethod
@since 1.2.0
*/
- registerAsyncHelper: function (name, helperMethod) {
+ registerAsyncHelper: function(name, helperMethod) {
helpers[name] = {
method: helperMethod,
meta: { wait: true }
};
},
/**
Remove a previously added helper method.
- Example:
- ```javascript
+
+ Example:
+
+ ```javascript
Ember.Test.unregisterHelper('wait');
```
- @public
+
+ @public
@method unregisterHelper
@param {String} name The helper to remove.
*/
- unregisterHelper: function (name) {
+ unregisterHelper: function(name) {
delete helpers[name];
delete Test.Promise.prototype[name];
},
/**
Used to register callbacks to be fired whenever `App.injectTestHelpers`
is called.
- The callback will receive the current application as an argument.
- Example:
- ```javascript
+
+ The callback will receive the current application as an argument.
+
+ Example:
+
+ ```javascript
Ember.Test.onInjectHelpers(function() {
Ember.$(document).ajaxSend(function() {
Test.pendingAjaxRequests++;
});
- Ember.$(document).ajaxComplete(function() {
+
+ Ember.$(document).ajaxComplete(function() {
Test.pendingAjaxRequests--;
});
});
```
- @public
+
+ @public
@method onInjectHelpers
@param {Function} callback The function to be called.
*/
- onInjectHelpers: function (callback) {
+ onInjectHelpers: function(callback) {
injectHelpersCallbacks.push(callback);
},
/**
This returns a thenable tailored for testing. It catches failed
`onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
callback in the last chained then.
- This method should be returned by async helpers such as `wait`.
- @public
+
+ This method should be returned by async helpers such as `wait`.
+
+ @public
@method promise
@param {Function} resolver The function used to resolve the promise.
*/
- promise: function (resolver) {
+ promise: function(resolver) {
return new Test.Promise(resolver);
},
/**
Used to allow ember-testing to communicate with a specific testing
framework.
- You can manually set it before calling `App.setupForTesting()`.
- Example:
- ```javascript
+
+ You can manually set it before calling `App.setupForTesting()`.
+
+ Example:
+
+ ```javascript
Ember.Test.adapter = MyCustomAdapter.create()
```
- If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
- @public
+
+ If you do not set it, ember-testing will default to `Ember.Test.QUnitAdapter`.
+
+ @public
@property adapter
@type {Class} The adapter to be used.
@default Ember.Test.QUnitAdapter
*/
adapter: null,
/**
Replacement for `Ember.RSVP.resolve`
The only difference is this uses
an instance of `Ember.Test.Promise`
- @public
+
+ @public
@method resolve
@param {Mixed} The value to resolve
@since 1.2.0
*/
- resolve: function (val) {
- return Test.promise(function (resolve) {
+ resolve: function(val) {
+ return Test.promise(function(resolve) {
return resolve(val);
});
},
/**
This allows ember-testing to play nicely with other asynchronous
events, such as an application that is waiting for a CSS3
transition or an IndexDB transaction.
- For example:
- ```javascript
+
+ For example:
+
+ ```javascript
Ember.Test.registerWaiter(function() {
return myPendingTransactions() == 0;
});
```
The `context` argument allows you to optionally specify the `this`
with which your callback will be invoked.
- For example:
- ```javascript
+
+ For example:
+
+ ```javascript
Ember.Test.registerWaiter(MyDB, MyDB.hasPendingTransactions);
```
- @public
+
+ @public
@method registerWaiter
@param {Object} context (optional)
@param {Function} callback
@since 1.2.0
*/
- registerWaiter: function (context, callback) {
+ registerWaiter: function(context, callback) {
if (arguments.length === 1) {
callback = context;
context = null;
}
if (!this.waiters) {
@@ -1225,35 +1268,34 @@
this.waiters.push([context, callback]);
},
/**
`unregisterWaiter` is used to unregister a callback that was
registered with `registerWaiter`.
- @public
+
+ @public
@method unregisterWaiter
@param {Object} context (optional)
@param {Function} callback
@since 1.2.0
*/
- unregisterWaiter: function (context, callback) {
- if (!this.waiters) {
- return;
- }
+ unregisterWaiter: function(context, callback) {
+ if (!this.waiters) { return; }
if (arguments.length === 1) {
callback = context;
context = null;
}
- this.waiters = Ember['default'].A(this.waiters.filter(function (elt) {
+ this.waiters = Ember['default'].A(this.waiters.filter(function(elt) {
return !(elt[0] === context && elt[1] === callback);
}));
}
};
function helper(app, name) {
var fn = helpers[name].method;
var meta = helpers[name].meta;
- return function () {
+ return function() {
var args = slice.call(arguments);
var lastPromise;
args.unshift(app);
@@ -1262,22 +1304,22 @@
// example: `find`
if (!meta.wait) {
return fn.apply(app, args);
}
- lastPromise = run(function () {
+ lastPromise = run(function() {
return Test.resolve(Test.lastPromise);
});
// wait for last helper's promise to resolve and then
// execute. To be safe, we need to tell the adapter we're going
// asynchronous here, because fn may not be invoked before we
// return.
Test.adapter.asyncStart();
- return lastPromise.then(function () {
+ return lastPromise.then(function() {
return fn.apply(app, args);
- })["finally"](function () {
+ })["finally"](function() {
Test.adapter.asyncEnd();
});
};
}
@@ -1293,34 +1335,39 @@
/**
This property contains the testing helpers for the current application. These
are created once you call `injectTestHelpers` on your `Ember.Application`
instance. The included helpers are also available on the `window` object by
default, but can be used from this object on the individual application also.
- @property testHelpers
+
+ @property testHelpers
@type {Object}
@default {}
*/
testHelpers: {},
/**
This property will contain the original methods that were registered
on the `helperContainer` before `injectTestHelpers` is called.
- When `removeTestHelpers` is called, these methods are restored to the
+
+ When `removeTestHelpers` is called, these methods are restored to the
`helperContainer`.
- @property originalMethods
+
+ @property originalMethods
@type {Object}
@default {}
@private
@since 1.3.0
*/
originalMethods: {},
+
/**
This property indicates whether or not this application is currently in
testing mode. This is set when `setupForTesting` is called on the current
application.
- @property testing
+
+ @property testing
@type {Boolean}
@default false
@since 1.3.0
*/
testing: false,
@@ -1329,30 +1376,34 @@
This hook defers the readiness of the application, so that you can start
the app when your tests are ready to run. It also sets the router's
location to 'none', so that the window's location will not be modified
(preventing both accidental leaking of state between tests and interference
with your testing framework).
- Example:
- ```
+
+ Example:
+
+ ```
App.setupForTesting();
```
- @method setupForTesting
+
+ @method setupForTesting
*/
- setupForTesting: function () {
+ setupForTesting: function() {
setupForTesting['default']();
this.testing = true;
this.Router.reopen({
- location: "none"
+ location: 'none'
});
},
/**
This will be used as the container to inject the test helpers into. By
default the helpers are injected into `window`.
- @property helperContainer
+
+ @property helperContainer
@type {Object} The object to be used for test helpers.
@default window
@since 1.2.0
*/
helperContainer: null,
@@ -1361,19 +1412,22 @@
This injects the test helpers into the `helperContainer` object. If an object is provided
it will be used as the helperContainer. If `helperContainer` is not set it will default
to `window`. If a function of the same name has already been defined it will be cached
(so that it can be reset if the helper is removed with `unregisterHelper` or
`removeTestHelpers`).
- Any callbacks registered with `onInjectHelpers` will be called once the
+
+ Any callbacks registered with `onInjectHelpers` will be called once the
helpers have been injected.
- Example:
+
+ Example:
```
App.injectTestHelpers();
```
- @method injectTestHelpers
+
+ @method injectTestHelpers
*/
- injectTestHelpers: function (helperContainer) {
+ injectTestHelpers: function(helperContainer) {
if (helperContainer) {
this.helperContainer = helperContainer;
} else {
this.helperContainer = window;
}
@@ -1391,21 +1445,22 @@
},
/**
This removes all helpers that have been registered, and resets and functions
that were overridden by the helpers.
- Example:
- ```javascript
+
+ Example:
+
+ ```javascript
App.removeTestHelpers();
```
- @public
+
+ @public
@method removeTestHelpers
*/
- removeTestHelpers: function () {
- if (!this.helperContainer) {
- return;
- }
+ removeTestHelpers: function() {
+ if (!this.helperContainer) { return; }
for (var name in helpers) {
this.helperContainer[name] = this.originalMethods[name];
delete this.testHelpers[name];
delete this.originalMethods[name];
@@ -1415,23 +1470,23 @@
// This method is no longer needed
// But still here for backwards compatibility
// of helper chaining
function protoWrap(proto, name, callback, isAsync) {
- proto[name] = function () {
+ proto[name] = function() {
var args = arguments;
if (isAsync) {
return callback.apply(this, args);
} else {
- return this.then(function () {
+ return this.then(function() {
return callback.apply(this, args);
});
}
};
}
- Test.Promise = function () {
+ Test.Promise = function() {
RSVP['default'].Promise.apply(this, arguments);
Test.lastPromise = this;
};
Test.Promise.prototype = create['default'](RSVP['default'].Promise.prototype);
@@ -1439,12 +1494,12 @@
Test.Promise.resolve = Test.resolve;
// Patch `then` to isolate async methods
// specifically `Ember.Test.lastPromise`
var originalThen = RSVP['default'].Promise.prototype.then;
- Test.Promise.prototype.then = function (onSuccess, onFailure) {
- return originalThen.call(this, function (val) {
+ Test.Promise.prototype.then = function(onSuccess, onFailure) {
+ return originalThen.call(this, function(val) {
return isolate(onSuccess, val);
}, onFailure);
};
// This method isolates nested async methods
@@ -1465,22 +1520,134 @@
Test.lastPromise = null;
// If the method returned a promise
// return that promise. If not,
// return the last async helper's promise
- if (value && value instanceof Test.Promise || !lastPromise) {
+ if ((value && (value instanceof Test.Promise)) || !lastPromise) {
return value;
} else {
- return run(function () {
- return Test.resolve(lastPromise).then(function () {
+ return run(function() {
+ return Test.resolve(lastPromise).then(function() {
return value;
});
});
}
}
exports['default'] = Test;
});
+enifed("htmlbars-test-helpers",
+ ["exports"],
+ function(__exports__) {
+ "use strict";
+ function equalInnerHTML(fragment, html) {
+ var actualHTML = normalizeInnerHTML(fragment.innerHTML);
+ QUnit.push(actualHTML === html, actualHTML, html);
+ }
+
+ __exports__.equalInnerHTML = equalInnerHTML;function equalHTML(node, html) {
+ var fragment;
+ if (!node.nodeType && node.length) {
+ fragment = document.createDocumentFragment();
+ while (node[0]) {
+ fragment.appendChild(node[0]);
+ }
+ } else {
+ fragment = node;
+ }
+
+ var div = document.createElement("div");
+ div.appendChild(fragment.cloneNode(true));
+
+ equalInnerHTML(div, html);
+ }
+
+ __exports__.equalHTML = equalHTML;// detect weird IE8 html strings
+ var ie8InnerHTMLTestElement = document.createElement('div');
+ ie8InnerHTMLTestElement.setAttribute('id', 'womp');
+ var ie8InnerHTML = (ie8InnerHTMLTestElement.outerHTML.indexOf('id=womp') > -1);
+
+ // detect side-effects of cloning svg elements in IE9-11
+ var ieSVGInnerHTML = (function () {
+ if (!document.createElementNS) {
+ return false;
+ }
+ var div = document.createElement('div');
+ var node = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+ div.appendChild(node);
+ var clone = div.cloneNode(true);
+ return clone.innerHTML === '<svg xmlns="http://www.w3.org/2000/svg" />';
+ })();
+
+ function normalizeInnerHTML(actualHTML) {
+ if (ie8InnerHTML) {
+ // drop newlines in IE8
+ actualHTML = actualHTML.replace(/\r\n/gm, '');
+ // downcase ALLCAPS tags in IE8
+ actualHTML = actualHTML.replace(/<\/?[A-Z\-]+/gi, function(tag){
+ return tag.toLowerCase();
+ });
+ // quote ids in IE8
+ actualHTML = actualHTML.replace(/id=([^ >]+)/gi, function(match, id){
+ return 'id="'+id+'"';
+ });
+ // IE8 adds ':' to some tags
+ // <keygen> becomes <:keygen>
+ actualHTML = actualHTML.replace(/<(\/?):([^ >]+)/gi, function(match, slash, tag){
+ return '<'+slash+tag;
+ });
+
+ // Normalize the style attribute
+ actualHTML = actualHTML.replace(/style="(.+?)"/gi, function(match, val){
+ return 'style="'+val.toLowerCase()+';"';
+ });
+
+ }
+ if (ieSVGInnerHTML) {
+ // Replace `<svg xmlns="http://www.w3.org/2000/svg" height="50%" />` with `<svg height="50%"></svg>`, etc.
+ // drop namespace attribute
+ actualHTML = actualHTML.replace(/ xmlns="[^"]+"/, '');
+ // replace self-closing elements
+ actualHTML = actualHTML.replace(/<([^ >]+) [^\/>]*\/>/gi, function(tag, tagName) {
+ return tag.slice(0, tag.length - 3) + '></' + tagName + '>';
+ });
+ }
+
+ return actualHTML;
+ }
+
+ __exports__.normalizeInnerHTML = normalizeInnerHTML;// detect weird IE8 checked element string
+ var checkedInput = document.createElement('input');
+ checkedInput.setAttribute('checked', 'checked');
+ var checkedInputString = checkedInput.outerHTML;
+ function isCheckedInputHTML(element) {
+ equal(element.outerHTML, checkedInputString);
+ }
+
+ __exports__.isCheckedInputHTML = isCheckedInputHTML;// check which property has the node's text content
+ var textProperty = document.createElement('div').textContent === undefined ? 'innerText' : 'textContent';
+ function getTextContent(el) {
+ // textNode
+ if (el.nodeType === 3) {
+ return el.nodeValue;
+ } else {
+ return el[textProperty];
+ }
+ }
+
+ __exports__.getTextContent = getTextContent;// IE8 does not have Object.create, so use a polyfill if needed.
+ // Polyfill based on Mozilla's (MDN)
+ function createObject(obj) {
+ if (typeof Object.create === 'function') {
+ return Object.create(obj);
+ } else {
+ var Temp = function() {};
+ Temp.prototype = obj;
+ return new Temp();
+ }
+ }
+ __exports__.createObject = createObject;
+ });
requireModule("ember-testing");
})();
\ No newline at end of file