root/mochikit/branches/scriptaculous/tests/test_MochiKit-Async.html

Revision 578, 6.9 kB (checked in by therve@gmail.com, 3 years ago)

Sync tests

  • Property svn:mime-type set to text/html
  • Property svn:eol-style set to native
Line 
1 <html>
2 <head>
3     <script type="text/javascript" src="Test/Builder.js"></script>
4     <script type="text/javascript" src="Test/More.js"></script>
5     <script type="text/javascript" src="../MochiKit/Base.js"></script>
6     <script type="text/javascript" src="../MochiKit/Async.js"></script>
7 </head>
8 <body>
9
10 <pre id="test">
11 <script type="text/javascript">
12 try {
13        
14     // Counting the number of tests is really lame
15     plan({'tests': 35});
16
17     var increment = function (res) {
18         return res + 1;
19     }
20
21     var throwStuff = function (res) {
22         throw new GenericError(res);
23     }
24
25     var catchStuff = function (res) {
26         return res.message;
27     }
28
29     var returnError = function (res) {
30         return new GenericError(res);
31     }
32
33     var anythingOkCallback = function (msg) {
34         return function (res) {
35             ok(true, msg);
36             return res;
37         }
38     }
39    
40     var testEqCallback = function () {
41         /*
42             sort of emulate how deferreds work in Twisted
43             for "convenient" testing
44         */
45         var args = [];
46         for (var i = 0; i < arguments.length; i++) {
47             args.push(arguments[i]);
48         }
49         return function (res) {
50             var nargs = args.slice();
51             nargs.unshift(res);
52             is.apply(this, nargs);
53             return res;
54         }
55     }
56
57     var neverHappen = function (d) {
58         ok(false, "this should never happen");
59     }
60    
61     /*
62         Test normal Deferred operation
63     */
64     var d = new Deferred();
65     d.addCallback(testEqCallback(1, "pre-deferred callback"));
66     d.callback(1);
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"));
77
78     /*
79         Test Deferred cancellation
80     */
81     var cancelled = function (d) {
82         ok(true, "canceller called!");
83     }
84
85     var cancelledError = function (res) {
86         ok(res instanceof CancelledError, "CancelledError here");
87     }
88
89     d = new Deferred(cancelled);
90     d.addCallback(neverHappen);
91     d.addErrback(cancelledError);
92     d.cancel();
93
94     /*
95         Test succeed / fail
96     */
97
98     d = succeed(1).addCallback(testEqCallback(1, "succeed"));
99
100     // default error
101     d = fail().addCallback(neverHappen);
102     d = d.addErrback(anythingOkCallback("default fail"));
103
104     // default wrapped error
105     d = fail("web taco").addCallback(neverHappen).addErrback(catchStuff);
106     d = d.addCallback(testEqCallback("web taco", "wrapped fail"));
107
108     // default unwrapped error
109     d = fail(new GenericError("ugh")).addCallback(neverHappen).addErrback(catchStuff);
110     d = d.addCallback(testEqCallback("ugh", "unwrapped fail"));
111
112     /*
113         Test deferred dependencies
114     */
115
116     var deferredIncrement = function (res) {
117         var rval = succeed(res);
118         rval.addCallback(increment);
119         return rval;
120     }
121
122     d = succeed(1).addCallback(deferredIncrement);
123     d = d.addCallback(testEqCallback(2, "dependent deferred succeed"));
124
125     var deferredFailure = function (res) {
126         return fail(res);
127     }
128
129     d = succeed("ugh").addCallback(deferredFailure).addErrback(catchStuff);
130     d = d.addCallback(testEqCallback("ugh", "dependent deferred fail"));
131
132     /*
133         Test double-calling, double-failing, etc.
134     */
135     try {
136         succeed(1).callback(2);
137         neverHappen();
138     } catch (e) {
139         ok(e instanceof AlreadyCalledError, "double-call");
140     }
141     try {
142         fail(1).errback(2);
143         neverHappen();
144     } catch (e) {
145         ok(e instanceof AlreadyCalledError, "double-fail");
146     }
147     try {
148         d = succeed(1);
149         d.cancel();
150         d = d.callback(2);
151         ok(true, "swallowed one callback, no canceller");
152         d.callback(3);
153         neverHappen();
154     } catch (e) {
155         ok(e instanceof AlreadyCalledError, "swallow cancel");
156     }
157     try {
158         d = new Deferred(cancelled);
159         d.cancel();
160         d = d.callback(1);
161         neverHappen();
162     } catch (e) {
163         ok(e instanceof AlreadyCalledError, "non-swallowed cancel");
164     }
165    
166     /*
167         evalJSONRequest test
168     */
169     var fakeReq = {"responseText":'[1,2,3,4,"asdf",{"a":["b", "c"]}]'};
170     var obj = [1,2,3,4,"asdf",{"a":["b", "c"]}];
171     isDeeply(obj, evalJSONRequest(fakeReq), "evalJSONRequest");
172
173     try {
174         MochiKit.Async.getXMLHttpRequest();
175         ok(true, "getXMLHttpRequest");
176     } catch (e) {
177         ok(false, "no love from getXMLHttpRequest");
178     }
179    
180     var lock = new DeferredLock();
181     var lst = [];
182     var pushNumber = function (x) {
183         return function (res) { lst.push(x); }
184     };
185     lock.acquire().addCallback(pushNumber(1));
186     is( compare(lst, [1]), 0, "lock acquired" );
187     lock.acquire().addCallback(pushNumber(2));
188     is( compare(lst, [1]), 0, "lock waiting for release" );
189     lock.acquire().addCallback(pushNumber(3));
190     is( compare(lst, [1]), 0, "lock waiting for release" );
191     lock.release();
192     is( compare(lst, [1, 2]), 0, "lock passed on" );
193     lock.release();
194     is( compare(lst, [1, 2, 3]), 0, "lock passed on" );
195     lock.release();
196     try {
197         lock.release();
198         ok( false, "over-release didn't raise" );
199     } catch (e) {
200         ok( true, "over-release raised" );
201     }
202     lock.acquire().addCallback(pushNumber(1));
203     is( compare(lst, [1, 2, 3, 1]), 0, "lock acquired" );
204     lock.release();
205     is( compare(lst, [1, 2, 3, 1]), 0, "lock released" );
206
207     var d = new Deferred();
208     lst = [];
209     d.addCallback(operator.add, 2);
210     d.addBoth(operator.add, 4);
211     d.addCallback(bind(lst.push, lst));
212     d.callback(1);
213     is( lst[0], 7, "auto-partial addCallback addBoth" );
214     d.addCallback(function () { throw new Error(); });
215     ebTest = function(a, b) {
216         map(bind(lst.push, lst), arguments);
217     };
218     d.addErrback(ebTest, "foo");
219     is( lst[1], "foo", "auto-partial errback" );
220     is( lst.length, 3, "auto-partial errback" );
221
222    
223     ok( true, "synchronous test suite finished!");
224
225     var t = (new Date().getTime());
226     var endtest = 0;
227     checkCallLater = function (originalTime) {
228         is(originalTime, t, "argument passed in OK");
229         is(arguments.length, 1, "argument count right");
230         if (endtest) {
231             tx.endAsync(async);
232         }
233         endtest++;
234     };
235     var tx = new Test.Builder();
236     var async = tx.beginAsync(1000);
237     callLater(0.25, checkCallLater, t);
238     wait(0.25, t).addCallback(checkCallLater);
239    
240 } catch (err) {
241    
242     var s = "test suite failure!\n";
243     var o = {};
244     var k = null;
245     for (k in err) {
246         // ensure unique keys?!
247         if (!o[k]) {
248             s +=  k + ": " + err[k] + "\n";
249             o[k] = err[k];
250         }
251     }
252     ok ( false, s );
253
254 }
255 </script>
256 </pre>
257 </body>
258 </html>
Note: See TracBrowser for help on using the browser.