Test: Asynchronous Testing
+ ++
This example shows how to create an asynchronous test with the YUI Test framework for testing browser-based JavaScript code.
+ A Y.Test.Case object is created with a test that waits for a
+ few seconds before continuing. The Y.Test.Runner
+ is then used to run the tests once the page has loaded.
Asynchronous Test Example
+ +This example begins by creating a namespace:
+ +This namespace serves as the core object upon which others will be added (to prevent creating global objects).
+ +Creating the TestCase
+ +The first step is to create a new Y.Test.Case object called AsyncTestCase.
+ To do so, using the Y.Test.Case constructor and pass in an object literal containing information about the tests to be run:
The object literal passed into the constructor contains two different sections. The first section contains the name property,
+ which is used to determine which Y.Test.Case is being executed. A name is necessary, so one is generated if it isn't specified.
Next, the setUp() and tearDown() methods are included. The setUp() method is used in a Y.Test.Case
+ to set up data that may be needed for tests to be completed. This method is called immediately before each test is executed. For this example,
+ setUp() creates a data object. The tearDown() is responsible for undoing what was done in setUp(). It is
+ run immediately after each test is run and, in this case, deletes the data object that was created by setUp. These methods are optional.
The second section contains the actual tests to be run. The only test is testWait(), which demonstrates using
+ the wait() method to delay test execution. There are two arguments passed in: a function to run once the test resumes
+ and the number of milliseconds to wait before running this function (same basic format as setTimeout()). When
+ the test resumes, the function is executed in the context of the Y.Test.Case object, meaning that it still has
+ access to all of the same data as the test that called wait(), including properties and methods on the Y.Test.Case
+ itself. This example shows the anonymous function using both the Y.Assert object and the data property
+ of the Y.Test.Case.
Running the tests
+ +With all of the tests defined, the last step is to run them:
+ + + +Before running the tests, it's necessary to create a Y.Console object to display the results (otherwise the tests would run
+ but you wouldn't see the results). After that, the Y.Test.Runner is loaded with the Y.Test.Case object by calling
+ add() (any number of Y.Test.Case and TestSuite objects can be added to a TestRunner,
+ this example only adds one for simplicity). The very last step is to call run(), which begins executing the tests in its
+ queue and displays the results in the Y.Console.