Ember.Test Class packages/ember-testing/lib/test.js:10
Defined in: packages/ember-testing/lib/test.js:10
Module: ember-testing
This is a container for an assortment of testing related functionality:
- Choose your default test adapter (for your framework of choice).
- Register/Unregister additional test helpers.
- Setup callbacks to be fired when the test helpers are injected into your application.
Methods
- click
- fillIn
- find
- findWithAssert
- injectTestHelpers
- keyEvent
- onInjectHelpers
- promise
- registerAsyncHelper
- registerHelper
- registerWaiter
- removeTestHelpers
- resolve
- setupForTesting
- testCheckboxClick
- unregisterHelper
- unregisterWaiter
- visit
- wait
Properties
click
(selector)
RSVP.Promise
Clicks an element and triggers any actions triggered by the element's click
event.
Example:
1 2 3 |
click('.some-jQuery-selector').then(function() {
// assert something
});
|
Parameters:
- selector String
- jQuery selector for finding element on the DOM
Returns:
- RSVP.Promise
fillIn
(selector, text)
RSVP.Promise
Fills in an input element with some text.
Example:
1 2 3 |
fillIn('#email', 'you@example.com').then(function() {
// assert something
});
|
Parameters:
Returns:
- RSVP.Promise
find
(selector)
Object
Finds an element in the context of the app's container element. A simple alias
for app.$(selector).
Example:
1 |
var $el = find('.my-selector);
|
Parameters:
- selector String
- jQuery string selector for element lookup
Returns:
- Object
- jQuery object representing the results of the query
findWithAssert
(selector)
Object
Like find, but throws an error if the element selector returns no results
Example:
var $el = findWithAssert('.doesnt-exist'); // throws error
Parameters:
- selector String
- jQuery selector string for finding an element within the DOM
Returns:
- Object
- jQuery object representing the results of the query
injectTestHelpers
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
helpers have been injected.
Example:
App.injectTestHelpers();
keyEvent
(selector, the, the)
RSVP.Promise
Simulates a key event, e.g. keypress, keydown, keyup with the desired keyCode
Example:
1 2 3 |
keyEvent('.some-jQuery-selector', 'keypress', 13).then(function() {
// assert something
});
|
Parameters:
Returns:
- RSVP.Promise
onInjectHelpers
(callback)
public
Used to register callbacks to be fired whenever App.injectTestHelpers
is called.
The callback will receive the current application as an argument.
Example: ``` Ember.Test.onInjectHelpers(function() { Ember.$(document).ajaxStart(function() { Test.pendingAjaxRequests++; });
Ember.$(document).ajaxStop(function() { Test.pendingAjaxRequests--; }); }); ```
Parameters:
- callback Function
- The function to be called.
promise
(resolver)
public
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.
Parameters:
- resolver Function
- The function used to resolve the promise.
registerAsyncHelper
(name, helperMethod)
public
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 first parameter.
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 until the last async helper has completed. All async helpers after it will wait for it complete before running.
For example: ```javascript Ember.Test.registerAsyncHelper('deletePost', function(app, postId) { click('.delete-' + postId); });
// ... in your test visit('/post/2'); deletePost(2); visit('/post/3'); deletePost(3); ```
registerHelper
(name, helperMethod, options)
public
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 first parameter.
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
called with app as the first parameter.
1 2 3 |
App = Ember.Application.create(); App.injectTestHelpers(); boot(); |
removeTestHelpers
public
This removes all helpers that have been registered, and resets and functions that were overridden by the helpers.
Example:
App.removeTestHelpers();
resolve
(The)
public
Replacement for Ember.RSVP.resolve
The only difference is this uses
and instance of Ember.Test.Promise
Parameters:
- The Mixed
- value to resolve
setupForTesting
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:
App.setupForTesting();
testCheckboxClick
private
This method creates a checkbox and triggers the click event to fire the passed in handler. It is used to correct for a bug in older versions of jQuery (e.g 1.8.3).
unregisterHelper
(name)
public
Remove a previously added helper method.
Example:
Ember.Test.unregisterHelper('wait');
Parameters:
- name String
- The helper to remove.
unregisterWaiter
(context, callback)
public
unregisterWaiter is used to unregister a callback that was
registered with registerWaiter.
Parameters:
- context Object
- (optional)
- callback Function
visit
(url)
RSVP.Promise
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.
Example:
1 2 3 |
visit('posts/index').then(function() {
// assert something
});
|
Parameters:
- url String
- the name of the route
Returns:
- RSVP.Promise
wait
(value)
RSVP.Promise
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.
This is most often used as the return value for the helper functions (see 'click', 'fillIn','visit',etc).
Example:
1 2 3 4 5 6 7 8 |
Ember.Test.registerAsyncHelper('loginUser', function(app, username, password) {
visit('secured/path/here')
.fillIn('#username', username)
.fillIn('#password', username)
.click('.submit')
return wait();
});
|
Parameters:
- value Object
- The value to be returned.
Returns:
- RSVP.Promise
- ```
adapter
{Class} The adapter to be used.
public
Used to allow ember-testing to communicate with a specific testing framework.
You can manually set it before calling App.setupForTesting().
Example:
Ember.Test.adapter = MyCustomAdapter.create()
If you do not set it, ember-testing will default to Ember.Test.QUnitAdapter.
Default: Ember.Test.QUnitAdapter
helperContainer
{Object} The object to be used for test helpers.
This will be used as the container to inject the test helpers into. By
default the helpers are injected into window.
Default: window
testHelpers
{Object}
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.
Default: {}