3 <script type=
"text/javascript" src=
"../MochiKit/Base.js"></script>
4 <script type=
"text/javascript" src=
"../MochiKit/Async.js"></script>
5 <script type=
"text/javascript" src=
"../MochiKit/Iter.js"></script>
6 <script type=
"text/javascript" src=
"../MochiKit/DOM.js"></script>
7 <script type=
"text/javascript" src=
"../MochiKit/Style.js"></script>
8 <script type=
"text/javascript" src=
"SimpleTest/SimpleTest.js"></script>
9 <link rel=
"stylesheet" type=
"text/css" href=
"SimpleTest/test.css">
14 <script type=
"text/javascript">
17 var increment = function (res) {
21 var throwStuff = function (res) {
22 throw new GenericError(res);
25 var catchStuff = function (res) {
29 var returnError = function (res) {
30 return new GenericError(res);
33 var anythingOkCallback = function (msg) {
34 return function (res) {
40 var testEqCallback = function () {
42 sort of emulate how deferreds work in Twisted
43 for
"convenient" testing
46 for (var i =
0; i < arguments.length; i++) {
47 args.push(arguments[i]);
49 return function (res) {
50 var nargs = args.slice();
52 is.apply(this, nargs);
57 var neverHappen = function (d) {
58 ok(false,
"this should never happen");
62 Test normal Deferred operation
64 var d = new Deferred();
65 d.addCallback(testEqCallback(
1,
"pre-deferred callback"));
67 d.addCallback(increment);
68 d.addCallback(testEqCallback(
2,
"post-deferred callback"));
69 d.addCallback(throwStuff);
70 d.addCallback(neverHappen);
71 d.addErrback(catchStuff);
72 d.addCallback(testEqCallback(
2,
"throw -> err, catch -> success"));
73 d.addCallback(returnError);
74 d.addCallback(neverHappen);
75 d.addErrback(catchStuff);
76 d.addCallback(testEqCallback(
2,
"return -> err, catch -> succcess"));
79 Test Deferred cancellation
81 var cancelled = function (d) {
82 ok(true,
"canceller called!");
85 var cancelledError = function (res) {
86 ok(res instanceof CancelledError,
"CancelledError here");
89 d = new Deferred(cancelled);
90 d.addCallback(neverHappen);
91 d.addErrback(cancelledError);
98 d = succeed(
1).addCallback(testEqCallback(
1,
"succeed"));
101 d = fail().addCallback(neverHappen);
102 d = d.addErrback(anythingOkCallback(
"default fail"));
104 // default wrapped error
105 d = fail(
"web taco").addCallback(neverHappen).addErrback(catchStuff);
106 d = d.addCallback(testEqCallback(
"web taco",
"wrapped fail"));
108 // default unwrapped error
109 d = fail(new GenericError(
"ugh")).addCallback(neverHappen).addErrback(catchStuff);
110 d = d.addCallback(testEqCallback(
"ugh",
"unwrapped fail"));
113 Test deferred dependencies
116 var deferredIncrement = function (res) {
117 var rval = succeed(res);
118 rval.addCallback(increment);
122 d = succeed(
1).addCallback(deferredIncrement);
123 d = d.addCallback(testEqCallback(
2,
"dependent deferred succeed"));
125 var deferredFailure = function (res) {
129 d = succeed(
"ugh").addCallback(deferredFailure).addErrback(catchStuff);
130 d = d.addCallback(testEqCallback(
"ugh",
"dependent deferred fail"));
133 Test double-calling, double-failing, etc.
136 succeed(
1).callback(
2);
139 ok(e instanceof AlreadyCalledError,
"double-call");
145 ok(e instanceof AlreadyCalledError,
"double-fail");
151 ok(true,
"swallowed one callback, no canceller");
155 ok(e instanceof AlreadyCalledError,
"swallow cancel");
158 d = new Deferred(cancelled);
163 ok(e instanceof AlreadyCalledError,
"non-swallowed cancel");
166 /* Test incorrect Deferred usage */
170 d.callback(new Deferred());
173 ok (e instanceof Error,
"deferred not allowed for callback");
177 d.errback(new Deferred());
180 ok (e instanceof Error,
"deferred not allowed for errback");
184 (new Deferred()).addCallback(function () { return d; }).callback(
1);
186 d.addCallback(function () {});
189 ok (e instanceof Error,
"chained deferred not allowed to be re-used");
195 var fakeReq = {
"responseText":'[
1,
2,
3,
4,
"asdf",{
"a":[
"b",
"c"]}]'};
196 var obj = [
1,
2,
3,
4,
"asdf",{
"a":[
"b",
"c"]}];
197 isDeeply(obj, evalJSONRequest(fakeReq),
"evalJSONRequest");
200 MochiKit.Async.getXMLHttpRequest();
201 ok(true,
"getXMLHttpRequest");
203 ok(false,
"no love from getXMLHttpRequest");
206 var lock = new DeferredLock();
208 var pushNumber = function (x) {
209 return function (res) { lst.push(x); }
211 lock.acquire().addCallback(pushNumber(
1));
212 is( compare(lst, [
1]),
0,
"lock acquired" );
213 lock.acquire().addCallback(pushNumber(
2));
214 is( compare(lst, [
1]),
0,
"lock waiting for release" );
215 lock.acquire().addCallback(pushNumber(
3));
216 is( compare(lst, [
1]),
0,
"lock waiting for release" );
218 is( compare(lst, [
1,
2]),
0,
"lock passed on" );
220 is( compare(lst, [
1,
2,
3]),
0,
"lock passed on" );
224 ok( false,
"over-release didn't raise" );
226 ok( true,
"over-release raised" );
228 lock.acquire().addCallback(pushNumber(
1));
229 is( compare(lst, [
1,
2,
3,
1]),
0,
"lock acquired" );
231 is( compare(lst, [
1,
2,
3,
1]),
0,
"lock released" );
233 var d = new Deferred();
235 d.addCallback(operator.add,
2);
236 d.addBoth(operator.add,
4);
237 d.addCallback(bind(lst.push, lst));
239 is( lst[
0],
7,
"auto-partial addCallback addBoth" );
240 d.addCallback(function () { throw new Error(); });
241 ebTest = function(a, b) {
242 map(bind(lst.push, lst), arguments);
244 d.addErrback(ebTest,
"foo");
245 is( lst[
1],
"foo",
"auto-partial errback" );
246 is( lst.length,
3,
"auto-partial errback" );
252 var callList = [new Deferred(), new Deferred(), new Deferred()];
253 callList[
0].addCallback(increment);
254 callList[
1].addCallback(increment);
255 callList[
2].addCallback(increment);
256 var defList = new DeferredList(callList);
257 ok(defList instanceof Deferred,
"DeferredList looks like a Deferred");
259 callList[
0].callback(
3);
260 callList[
1].callback(
5);
261 callList[
2].callback(
4);
263 defList.addCallback(function (lst) {
264 is( arrayEqual(lst, [[true,
4], [true,
6], [true,
5]]),
1,
265 "deferredlist result ok" );
269 Test fireOnOneCallback
272 var callList2 = [new Deferred(), new Deferred(), new Deferred()];
273 callList2[
0].addCallback(increment);
274 callList2[
1].addCallback(increment);
275 callList2[
2].addCallback(increment);
276 var defList2 = new DeferredList(callList2, true);
277 callList2[
1].callback(
5);
278 callList2[
0].callback(
3);
279 callList2[
2].callback(
4);
281 defList2.addCallback(function (lst) {
282 is( arrayEqual(lst, [
1,
6]),
1,
"deferredlist fireOnOneCallback ok" );
286 Test fireOnOneErrback
289 var callList3 = [new Deferred(), new Deferred(), new Deferred()];
290 callList3[
0].addCallback(increment);
291 callList3[
1].addCallback(throwStuff);
292 callList3[
2].addCallback(increment);
293 var defList3 = new DeferredList(callList3, false, true);
294 defList3.callback = neverHappen;
295 callList3[
0].callback(
3);
296 callList3[
1].callback(
"foo");
297 callList3[
2].callback(
4);
299 defList3.addErrback(function (err) {
300 is( err.message,
"foo",
"deferredlist fireOnOneErrback ok" );
307 var callList4 = [new Deferred(), new Deferred(), new Deferred()];
308 callList4[
0].addCallback(increment);
309 callList4[
1].addCallback(throwStuff);
310 callList4[
2].addCallback(increment);
311 var defList4 = new DeferredList(callList4, false, false, true);
312 defList4.addErrback(neverHappen);
313 callList4[
1].addCallback(function (arg) {
314 is(arg, null,
"deferredlist consumeErrors ok" );
316 callList4[
0].callback(
3);
317 callList4[
1].callback(
"foo");
318 callList4[
2].callback(
4);
324 var callList5 = [new Deferred(), new Deferred(), new Deferred()];
325 callList5[
0].addCallback(increment);
326 callList5[
1].addCallback(increment);
327 callList5[
2].addCallback(increment);
328 var gatherRet = gatherResults(callList5);
329 callList5[
0].callback(
3);
330 callList5[
1].callback(
5);
331 callList5[
2].callback(
4);
333 gatherRet.addCallback(function (lst) {
334 is( arrayEqual(lst, [
4,
6,
5]),
1,
335 "gatherResults result ok" );
342 var maybeDef = maybeDeferred(increment,
4);
343 maybeDef.addCallback(testEqCallback(
5,
"maybeDeferred sync ok"));
345 var maybeDef2 = deferredIncrement(
8);
346 maybeDef2.addCallback(testEqCallback(
9,
"maybeDeferred async ok"));
348 ok( true,
"synchronous test suite finished!");
350 var t = (new Date().getTime());
351 SimpleTest.waitForExplicitFinish();
352 checkCallLater = function (originalTime) {
353 is(originalTime, t,
"argument passed in OK");
354 is(arguments.length,
1,
"argument count right");
356 var lock = new DeferredLock();
357 withLock = function (msg) {
358 var cb = partial.apply(null, extend(null, arguments,
1));
359 var d = lock.acquire().addCallback(cb);
360 d.addErrback(ok, false, msg);
361 d.addCallback(function () {
367 withLock(
"callLater", function () {
368 return callLater(
0.05, checkCallLater, t);
370 withLock(
"wait", function () {
371 return wait(
0.05, t).addCallback(checkCallLater);
373 withLock(
"loadJSONDoc", function () {
374 var d = loadJSONDoc(
"test_MochiKit-Async.json");
375 d.addCallback(function (doc) {
376 is(doc.passed, true,
"loadJSONDoc passed");
378 d.addErrback(function (doc) {
379 ok(false,
"loadJSONDoc failed");
383 lock.acquire().addCallback(function () {
384 ok(true,
"async suite finished");
391 var s =
"test suite failure!\n";
395 // ensure unique keys?!
397 s += k +
": " + err[k] +
"\n";