testing/mochitest/tests/test_MochiKit-Async.html

   1 <html>
   2 <head>
   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">
  10 </head>
  11 <body>
  12
  13 <pre id="test">
  14 <script type="text/javascript">
  15
  16 try {
  17
  18     var increment = function (res) {
  19         return res + 1;
  20     }
  21
  22     var throwStuff = function (res) {
  23         throw new GenericError(res);
  24     }
  25
  26     var catchStuff = function (res) {
  27         return res.message;
  28     }
  29
  30     var returnError = function (res) {
  31         return new GenericError(res);
  32     }
  33
  34     var anythingOkCallback = function (msg) {
  35         return function (res) {
  36             ok(true, msg);
  37             return res;
  38         }
  39     }
  40
  41     var testEqCallback = function () {
  42         /*
  43             sort of emulate how deferreds work in Twisted
  44             for "convenient" testing
  45         */
  46         var args = [];
  47         for (var i = 0; i < arguments.length; i++) {
  48             args.push(arguments[i]);
  49         }
  50         return function (res) {
  51             var nargs = args.slice();
  52             nargs.unshift(res);
  53             is.apply(this, nargs);
  54             return res;
  55         }
  56     }
  57
  58     var neverHappen = function (d) {
  59         ok(false, "this should never happen");
  60     }
  61
  62     /*
  63         Test normal Deferred operation
  64     */
  65     var d = new Deferred();
  66     d.addCallback(testEqCallback(1, "pre-deferred callback"));
  67     d.callback(1);
  68     d.addCallback(increment);
  69     d.addCallback(testEqCallback(2, "post-deferred callback"));
  70     d.addCallback(throwStuff);
  71     d.addCallback(neverHappen);
  72     d.addErrback(catchStuff);
  73     d.addCallback(testEqCallback(2, "throw -> err, catch -> success"));
  74     d.addCallback(returnError);
  75     d.addCallback(neverHappen);
  76     d.addErrback(catchStuff);
  77     d.addCallback(testEqCallback(2, "return -> err, catch -> succcess"));
  78
  79     /*
  80         Test Deferred cancellation
  81     */
  82     var cancelled = function (d) {
  83         ok(true, "canceller called!");
  84     }
  85
  86     var cancelledError = function (res) {
  87         ok(res instanceof CancelledError, "CancelledError here");
  88     }
  89
  90     d = new Deferred(cancelled);
  91     d.addCallback(neverHappen);
  92     d.addErrback(cancelledError);
  93     d.cancel();
  94
  95     /*
  96         Test succeed / fail
  97     */
  98
  99     d = succeed(1).addCallback(testEqCallback(1, "succeed"));
 100
 101     // default error
 102     d = fail().addCallback(neverHappen);
 103     d = d.addErrback(anythingOkCallback("default fail"));
 104
 105     // default wrapped error
 106     d = fail("web taco").addCallback(neverHappen).addErrback(catchStuff);
 107     d = d.addCallback(testEqCallback("web taco", "wrapped fail"));
 108
 109     // default unwrapped error
 110     d = fail(new GenericError("ugh")).addCallback(neverHappen).addErrback(catchStuff);
 111     d = d.addCallback(testEqCallback("ugh", "unwrapped fail"));
 112
 113     /*
 114         Test deferred dependencies
 115     */
 116
 117     var deferredIncrement = function (res) {
 118         var rval = succeed(res);
 119         rval.addCallback(increment);
 120         return rval;
 121     }
 122
 123     d = succeed(1).addCallback(deferredIncrement);
 124     d = d.addCallback(testEqCallback(2, "dependent deferred succeed"));
 125
 126     var deferredFailure = function (res) {
 127         return fail(res);
 128     }
 129
 130     d = succeed("ugh").addCallback(deferredFailure).addErrback(catchStuff);
 131     d = d.addCallback(testEqCallback("ugh", "dependent deferred fail"));
 132
 133     /*
 134         Test double-calling, double-failing, etc.
 135     */
 136     try {
 137         succeed(1).callback(2);
 138         neverHappen();
 139     } catch (e) {
 140         ok(e instanceof AlreadyCalledError, "double-call");
 141     }
 142     try {
 143         fail(1).errback(2);
 144         neverHappen();
 145     } catch (e) {
 146         ok(e instanceof AlreadyCalledError, "double-fail");
 147     }
 148     try {
 149         d = succeed(1);
 150         d.cancel();
 151         d = d.callback(2);
 152         ok(true, "swallowed one callback, no canceller");
 153         d.callback(3);
 154         neverHappen();
 155     } catch (e) {
 156         ok(e instanceof AlreadyCalledError, "swallow cancel");
 157     }
 158     try {
 159         d = new Deferred(cancelled);
 160         d.cancel();
 161         d = d.callback(1);
 162         neverHappen();
 163     } catch (e) {
 164         ok(e instanceof AlreadyCalledError, "non-swallowed cancel");
 165     }
 166
 167     /* Test incorrect Deferred usage */
 168
 169     d = new Deferred();
 170     try {
 171         d.callback(new Deferred());
 172         neverHappen();
 173     } catch (e) {
 174         ok (e instanceof Error, "deferred not allowed for callback");
 175     }
 176     d = new Deferred();
 177     try {
 178         d.errback(new Deferred());
 179         neverHappen();
 180     } catch (e) {
 181         ok (e instanceof Error, "deferred not allowed for errback");
 182     }
 183
 184     d = new Deferred();
 185     (new Deferred()).addCallback(function () { return d; }).callback(1);
 186     try {
 187         d.addCallback(function () {});
 188         neverHappen();
 189     } catch (e) {
 190         ok (e instanceof Error, "chained deferred not allowed to be re-used");
 191     }
 192
 193     /*
 194         evalJSONRequest test
 195     */
 196     var fakeReq = {"responseText":'[1,2,3,4,"asdf",{"a":["b", "c"]}]'};
 197     var obj = [1,2,3,4,"asdf",{"a":["b", "c"]}];
 198     isDeeply(obj, evalJSONRequest(fakeReq), "evalJSONRequest");
 199
 200     try {
 201         MochiKit.Async.getXMLHttpRequest();
 202         ok(true, "getXMLHttpRequest");
 203     } catch (e) {
 204         ok(false, "no love from getXMLHttpRequest");
 205     }
 206
 207     var lock = new DeferredLock();
 208     var lst = [];
 209     var pushNumber = function (x) {
 210         return function (res) { lst.push(x); }
 211     };
 212     lock.acquire().addCallback(pushNumber(1));
 213     is( compare(lst, [1]), 0, "lock acquired" );
 214     lock.acquire().addCallback(pushNumber(2));
 215     is( compare(lst, [1]), 0, "lock waiting for release" );
 216     lock.acquire().addCallback(pushNumber(3));
 217     is( compare(lst, [1]), 0, "lock waiting for release" );
 218     lock.release();
 219     is( compare(lst, [1, 2]), 0, "lock passed on" );
 220     lock.release();
 221     is( compare(lst, [1, 2, 3]), 0, "lock passed on" );
 222     lock.release();
 223     try {
 224         lock.release();
 225         ok( false, "over-release didn't raise" );
 226     } catch (e) {
 227         ok( true, "over-release raised" );
 228     }
 229     lock.acquire().addCallback(pushNumber(1));
 230     is( compare(lst, [1, 2, 3, 1]), 0, "lock acquired" );
 231     lock.release();
 232     is( compare(lst, [1, 2, 3, 1]), 0, "lock released" );
 233
 234     var d = new Deferred();
 235     lst = [];
 236     d.addCallback(operator.add, 2);
 237     d.addBoth(operator.add, 4);
 238     d.addCallback(bind(lst.push, lst));
 239     d.callback(1);
 240     is( lst[0], 7, "auto-partial addCallback addBoth" );
 241     d.addCallback(function () { throw new Error(); });
 242     ebTest = function(a, b) {
 243         map(bind(lst.push, lst), arguments);
 244     };
 245     d.addErrback(ebTest, "foo");
 246     is( lst[1], "foo", "auto-partial errback" );
 247     is( lst.length, 3, "auto-partial errback" );
 248
 249     /*
 250         Test DeferredList
 251     */
 252
 253     var callList = [new Deferred(), new Deferred(), new Deferred()];
 254     callList[0].addCallback(increment);
 255     callList[1].addCallback(increment);
 256     callList[2].addCallback(increment);
 257     var defList = new DeferredList(callList);
 258     ok(defList instanceof Deferred, "DeferredList looks like a Deferred");
 259
 260     callList[0].callback(3);
 261     callList[1].callback(5);
 262     callList[2].callback(4);
 263
 264     defList.addCallback(function (lst) {
 265         is( arrayEqual(lst, [[true, 4], [true, 6], [true, 5]]), 1,
 266            "deferredlist result ok" );
 267     });
 268
 269     /*
 270         Test fireOnOneCallback
 271     */
 272
 273     var callList2 = [new Deferred(), new Deferred(), new Deferred()];
 274     callList2[0].addCallback(increment);
 275     callList2[1].addCallback(increment);
 276     callList2[2].addCallback(increment);
 277     var defList2 = new DeferredList(callList2, true);
 278     callList2[1].callback(5);
 279     callList2[0].callback(3);
 280     callList2[2].callback(4);
 281
 282     defList2.addCallback(function (lst) {
 283         is( arrayEqual(lst, [1, 6]), 1, "deferredlist fireOnOneCallback ok" );
 284     });
 285
 286     /*
 287         Test fireOnOneErrback
 288     */
 289
 290     var callList3 = [new Deferred(), new Deferred(), new Deferred()];
 291     callList3[0].addCallback(increment);
 292     callList3[1].addCallback(throwStuff);
 293     callList3[2].addCallback(increment);
 294     var defList3 = new DeferredList(callList3, false, true);
 295     defList3.callback = neverHappen;
 296     callList3[0].callback(3);
 297     callList3[1].callback("foo");
 298     callList3[2].callback(4);
 299
 300     defList3.addErrback(function (err) {
 301         is( err.message, "foo", "deferredlist fireOnOneErrback ok" );
 302     });
 303
 304     /*
 305         Test consumeErrors
 306     */
 307
 308     var callList4 = [new Deferred(), new Deferred(), new Deferred()];
 309     callList4[0].addCallback(increment);
 310     callList4[1].addCallback(throwStuff);
 311     callList4[2].addCallback(increment);
 312     var defList4 = new DeferredList(callList4, false, false, true);
 313     defList4.addErrback(neverHappen);
 314     callList4[1].addCallback(function (arg) {
 315         is(arg, null, "deferredlist consumeErrors ok" );
 316     });
 317     callList4[0].callback(3);
 318     callList4[1].callback("foo");
 319     callList4[2].callback(4);
 320
 321     /*
 322         Test gatherResults
 323     */
 324
 325     var callList5 = [new Deferred(), new Deferred(), new Deferred()];
 326     callList5[0].addCallback(increment);
 327     callList5[1].addCallback(increment);
 328     callList5[2].addCallback(increment);
 329     var gatherRet = gatherResults(callList5);
 330     callList5[0].callback(3);
 331     callList5[1].callback(5);
 332     callList5[2].callback(4);
 333
 334     gatherRet.addCallback(function (lst) {
 335         is( arrayEqual(lst, [4, 6, 5]), 1,
 336            "gatherResults result ok" );
 337     });
 338
 339     /*
 340         Test maybeDeferred
 341     */
 342
 343     var maybeDef = maybeDeferred(increment, 4);
 344     maybeDef.addCallback(testEqCallback(5, "maybeDeferred sync ok"));
 345
 346     var maybeDef2 = deferredIncrement(8);
 347     maybeDef2.addCallback(testEqCallback(9, "maybeDeferred async ok"));
 348
 349     ok( true, "synchronous test suite finished!");
 350
 351     var t = (new Date().getTime());
 352     SimpleTest.waitForExplicitFinish();
 353     checkCallLater = function (originalTime) {
 354         is(originalTime, t, "argument passed in OK");
 355         is(arguments.length, 1, "argument count right");
 356     };
 357     var lock = new DeferredLock();
 358     withLock = function (msg) {
 359         var cb = partial.apply(null, extend(null, arguments, 1));
 360         var d = lock.acquire().addCallback(cb);
 361         d.addErrback(ok, false, msg);
 362         d.addCallback(function () {
 363             ok(true, msg);
 364             lock.release();
 365         });
 366         return d;
 367     }
 368     withLock("callLater", function () {
 369         return callLater(0.05, checkCallLater, t);
 370     });
 371     withLock("wait", function () {
 372         return wait(0.05, t).addCallback(checkCallLater);
 373     });
 374     withLock("loadJSONDoc", function () {
 375         var d = loadJSONDoc("test_MochiKit-Async.json");
 376         d.addCallback(function (doc) {
 377             is(doc.passed,  true, "loadJSONDoc passed");
 378         });
 379         d.addErrback(function (doc) {
 380             ok(false, "loadJSONDoc failed");
 381         });
 382         return d;
 383     });
 384     lock.acquire().addCallback(function () {
 385         ok(true, "async suite finished");
 386         SimpleTest.finish();
 387     });
 388
 389 } catch (err) {
 390
 391     var s = "test suite failure!\n";
 392     var o = {};
 393     var k = null;
 394     for (k in err) {
 395         // ensure unique keys?!
 396         if (!o[k]) {
 397             s +=  k + ": " + err[k] + "\n";
 398             o[k] = err[k];
 399         }
 400     }
 401     ok ( false, s );
 402     SimpleTest.finish();
 403
 404 }
 405 </script>
 406 </pre>
 407 </body>
 408 </html>