Although running tests from Rhino is tremendously useful, DOH
also provides a harness that allows you to automate running tests from
within a browser window. Basically, you just define a test as an
ordinary HTML page and then load the test page into the DOH test
runner using query string parameters in the test runner's URL;
internally, JavaScript in the test runner examines the query string,
pulls out configuration values such as testUrl
and uses them to inject your test
page into a frame.
Of course, you can still run your browser-based test without the DOH test runner, but you won't get a nice visual display with optional Homer Simpson sound effects if you're willing to read the test results as console output.
The following is an example test defined as an ordinary HTML page. Notice that the example uses a local installation of Dojo because as of version 1.1, DOH is not delivered via AOL's CDN:
<html> <head><title>Fun with DOH!</title> <script type="text/javascript" src="local/path/to/dojo/dojo.js"> </script> <script type="text/javascript"> dojo.require("doh.runner"); dojo.addOnLoad(function( ) { doh.register("fooTest", [ function foo( ) { var bar = []; bar.push(1); bar.push(2); bar.push(3); doh.is(bar.indexOf(1), 0); //not portable! } ]); doh.run( ); }); </script> </head> <body></body> </html>
Almost any web application test suite worth its salt is going
to involve a significant number of tests that depend upon
asynchronous conditions such as waiting for an animation to happen,
a server side callback to occur, and so on. Example 16-4 introduces how you
can create asynchronous test with DOH. The key concept is that a
doh.Deferred
(pretty much an
ordinary dojo.Deferred
with some
tweaks) except that it is internal to DOH and, as such, doesn't have
external dependencies. Chapter 4 included an extensive
discussion of Deferreds if you need a quick refresher.
Before the relevant code sample, here's the basic pattern at play for asynchronous testing with DOH:
Create a
doh.Deferred
that will be used to verify the results from asynchronous function (that returns back adojo.Deferred
)Call whatever asynchronous function returns back the
dojo.Deferred
and save a reference to itAdd callbacks and errbacks to the
dojo.Deferred
that will simply pass the asynchronous function's results through to thedoh.Deferred
's own callbacks and errbacks
Example 16-4. Skeleton for an asynchronous test
doh.register("foo", [ function( ) { var dohDfd = new doh.Deferred(); var expectedResult = "baz"; var dojoDfd = asynchronousBarFunction(); dojoDfd.addBoth(function(response, io) { //reference the dohDfd as needed... if (response == expectedResult) { dohDfd.callback(true); } else { dohDfd.errback(new Error( /* ... */)); } }); //...and return back the dohDfd return dohDfd; } ]);
Depending on your specific test constraints, you might provide
explicit timeout
values to ensure
that the asynchronous operations involved timeout according to your
specific testing criteria. At any rate, the key takeaway is that
asynchronous testing doesn't need to be terribly complicated; the
Deferred abstraction simplifies most of that complexity, so you're
left to focus on the task at hand.
Get Dojo: The Definitive Guide now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.