← Back to branch summary

~testplan-team/testplan/source-collection

« back to all changes in this revision

Viewing changes to htmlunit-2.4/src/test/resources/dojo/1.0.2/dojo/tests/_base/xhr.html

  • Committer: edA-qa mort-ora-y
  • Date: 2010-04-07 10:54:57 UTC
  • Revision ID: eda-qa@disemia.com-20100407105457-g46bvbsrjqtjujab
updating hmltunit src

Show diffs side-by-side

added added

removed removed

Lines of Context:
htmlunit-2.4/src/test/resources/dojo/1.0.2/dojo/tests/_base/xhr.html
1
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2
 
        "http://www.w3.org/TR/html4/strict.dtd">
3
 
<html>
4
 
        <head>
5
 
                <title>testing form and xhr utils</title>
6
 
                <style type="text/css">
7
 
                        @import "../../resources/dojo.css";
8
 
                </style>
9
 
                <script type="text/javascript" 
10
 
                        src="../../dojo.js" djConfig="isDebug: true"></script>
11
 
                <script type="text/javascript">
12
 
                        dojo.require("doh.runner");
13
 
                        dojo.addOnLoad(function(){
14
 
                                var f1fo = { blah: "blah" };
15
 
                                var f1foStr = "blah=blah";
16
 
                                var f1foJson = '{"blah": "blah"}';
17
 
 
18
 
                                var f2fo = { 
19
 
                                        blah: "blah",
20
 
                                        multi: [
21
 
                                                "thud",
22
 
                                                "thonk"
23
 
                                        ],
24
 
                                        textarea: "textarea_value"
25
 
                                };
26
 
                                var f2foStr = "blah=blah&multi=thud&multi=thonk&textarea=textarea_value";
27
 
                                var f2foJson = '{"blah": "blah", "multi": ["thud", "thonk"], "textarea": "textarea_value"}';
28
 
 
29
 
                                var f3fo = { 
30
 
                                        spaces: "string with spaces"
31
 
                                };
32
 
                                var f3foStr = "spaces=string%20with%20spaces&";
33
 
                                var f3foJson = '{"spaces": "string with spaces"}';
34
 
 
35
 
                                doh.register("t", 
36
 
                                        [
37
 
                                                function formNodeToObject(t){
38
 
                                                        t.is(f1fo , dojo.formToObject(dojo.byId("f1")));
39
 
                                                },
40
 
                                                function formIdToObject(t){
41
 
                                                        t.is(f1fo , dojo.formToObject("f1"));
42
 
                                                },
43
 
                                                function formToObjectWithMultiSelect(t){
44
 
                                                        t.is(f2fo , dojo.formToObject("f2"));
45
 
                                                },
46
 
                                                function objectToQuery(t){
47
 
                                                        t.is(f1foStr , dojo.objectToQuery(f1fo));
48
 
                                                },
49
 
                                                function objectToQueryArr(t){
50
 
                                                        t.is(f2foStr, dojo.objectToQuery(f2fo));
51
 
                                                },
52
 
                                                function formToQuery(t){
53
 
                                                        t.is(f1foStr, dojo.formToQuery("f1"));
54
 
                                                },
55
 
                                                function formToQueryArr(t){
56
 
                                                        t.is(f2foStr, dojo.formToQuery("f2"));
57
 
                                                },
58
 
                                                function formToJson(t){
59
 
                                                        t.is(f1foJson, dojo.formToJson("f1"));
60
 
                                                },
61
 
                                                function formToJsonArr(t){
62
 
                                                        t.is(f2foJson, dojo.formToJson("f2"));
63
 
                                                },
64
 
                                                function queryToObject(t){
65
 
                                                        t.is(f1fo , dojo.queryToObject(f1foStr));
66
 
                                                        t.is(f2fo , dojo.queryToObject(f2foStr));
67
 
                                                        t.is(f3fo , dojo.queryToObject(f3foStr));
68
 
                                                },
69
 
                                                function textContentHandler(t){
70
 
                                                        t.is("foo bar baz ", 
71
 
                                                                dojo._contentHandlers.text({
72
 
                                                                        responseText: "foo bar baz "
73
 
                                                                })
74
 
                                                        );
75
 
                                                },
76
 
                                                function jsonContentHandler(t){
77
 
                                                        var jsonObj = {
78
 
                                                                foo: "bar",
79
 
                                                                baz: [
80
 
                                                                        { thonk: "blarg" },
81
 
                                                                        "xyzzy!"
82
 
                                                                ]
83
 
                                                        };
84
 
                                                        t.is(jsonObj, 
85
 
                                                                dojo._contentHandlers.json({
86
 
                                                                        responseText: dojo.toJson(jsonObj)
87
 
                                                                })
88
 
                                                        );
89
 
                                                },
90
 
                                                function jsonCFContentHandler(t){
91
 
                                                        var jsonObj = {
92
 
                                                                foo: "bar",
93
 
                                                                baz: [
94
 
                                                                        { thonk: "blarg" },
95
 
                                                                        "xyzzy!"
96
 
                                                                ]
97
 
                                                        };
98
 
                                                        var e;
99
 
                                                        try{
100
 
                                                                dojo._contentHandlers["json-comment-filtered"]({
101
 
                                                                        responseText: dojo.toJson(jsonObj)
102
 
                                                                })
103
 
                                                        }catch(ex){
104
 
                                                                e = ex;
105
 
                                                        }finally{
106
 
                                                                // did we fail closed?
107
 
                                                                t.is((typeof e), "object");
108
 
                                                        }
109
 
                                                        t.is(jsonObj,
110
 
                                                                dojo._contentHandlers["json-comment-filtered"]({
111
 
                                                                        responseText: "\tblag\n/*"+dojo.toJson(jsonObj)+"*/\n\r\t\r"
112
 
                                                                })
113
 
                                                        );
114
 
                                                },
115
 
                                                function jsContentHandler(t){
116
 
                                                        var jsonObj = {
117
 
                                                                foo: "bar",
118
 
                                                                baz: [
119
 
                                                                        { thonk: "blarg" },
120
 
                                                                        "xyzzy!"
121
 
                                                                ]
122
 
                                                        };
123
 
                                                        t.is(jsonObj,
124
 
                                                                dojo._contentHandlers["javascript"]({
125
 
                                                                        responseText: "("+dojo.toJson(jsonObj)+")"
126
 
                                                                })
127
 
                                                        );
128
 
                                                        t.t(dojo._contentHandlers["javascript"]({
129
 
                                                                        responseText: "true;"
130
 
                                                                })
131
 
                                                        );
132
 
                                                        t.f(dojo._contentHandlers["javascript"]({
133
 
                                                                        responseText: "false;"
134
 
                                                                })
135
 
                                                        );
136
 
                                                },
137
 
                                                function xmlContentHandler(t){
138
 
                                                        var fauxObj = {
139
 
                                                                foo: "bar",
140
 
                                                                baz: [
141
 
                                                                        { thonk: "blarg" },
142
 
                                                                        "xyzzy!"
143
 
                                                                ]
144
 
                                                        };
145
 
                                                        t.is(fauxObj,
146
 
                                                                dojo._contentHandlers["xml"]({ responseXML: fauxObj })
147
 
                                                        );
148
 
                                                },
149
 
                                                function xhrGet(t){
150
 
                                                        var d = new doh.Deferred();
151
 
                                                        var td = dojo.xhrGet({
152
 
                                                                url: "xhr.html", // self
153
 
                                                                preventCache: true,
154
 
                                                                load: function(text, ioArgs){
155
 
                                                                        t.is(4, ioArgs.xhr.readyState);
156
 
                                                                        return text; //must return a value here or the parent test deferred fails.
157
 
                                                                }
158
 
                                                        });
159
 
                                                        t.t(td instanceof dojo.Deferred);
160
 
                                                        td.addCallback(d, "callback");
161
 
                                                        return d;
162
 
                                                },
163
 
                                                function xhrGet404(t){
164
 
                                                        var d = new doh.Deferred();
165
 
                                                        try{
166
 
                                                                var td = dojo.xhrGet({
167
 
                                                                        url: "xhr_blarg.html", // doesn't exist
168
 
                                                                        error: function(err, ioArgs){
169
 
                                                                                t.is(404, ioArgs.xhr.status);
170
 
                                                                                return err; //must return a value here or the parent test deferred fails.
171
 
                                                                        }
172
 
                                                                });
173
 
                                                                // td.addErrback(d, "callback");
174
 
                                                        }catch(e){
175
 
                                                                d.callback(true);
176
 
                                                        }
177
 
                                                        // return d;
178
 
                                                },
179
 
                                                function xhrGetContent(t){
180
 
                                                        var d = new doh.Deferred();
181
 
                                                        var td = dojo.xhrGet({
182
 
                                                                url: "xhr.html?color=blue",
183
 
                                                                content: {
184
 
                                                                        foo: [ "bar", "baz" ],
185
 
                                                                        thud: "thonk",
186
 
                                                                        xyzzy: 3
187
 
                                                                }
188
 
                                                        });
189
 
                                                        td.addCallback(function(text){
190
 
                                                                // console.debug(td, td.xhr, td.args);
191
 
                                                                t.is("xhr.html?color=blue&foo=bar&foo=baz&thud=thonk&xyzzy=3", 
192
 
                                                                                td.ioArgs.url);
193
 
                                                                d.callback(true);
194
 
                                                        });
195
 
                                                        return d;
196
 
                                                },
197
 
                                                function xhrGetForm(t){
198
 
                                                        var d = new doh.Deferred();
199
 
                                                        var td = dojo.xhrGet({
200
 
                                                                url: "xhr.html", // self
201
 
                                                                form: "f3"
202
 
                                                        });
203
 
                                                        td.addCallback(function(xhr){
204
 
                                                                // console.debug(td.args.url);
205
 
                                                                t.is("xhr.html?spaces=string%20with%20spaces", td.ioArgs.url);
206
 
                                                                d.callback(true);
207
 
                                                        });
208
 
                                                        return d;
209
 
                                                },
210
 
                                                function xhrGetFormWithContent(t){
211
 
                                                        // ensure that stuff passed via content over-rides
212
 
                                                        // what's specified in the form
213
 
                                                        var d = new doh.Deferred();
214
 
                                                        var td = dojo.xhrGet({
215
 
                                                                url: "xhr.html", // self
216
 
                                                                form: "f3",
217
 
                                                                content: { spaces: "blah" }
218
 
                                                        });
219
 
                                                        td.addCallback(function(xhr){
220
 
                                                                // console.debug(td.args.url);
221
 
                                                                t.is("xhr.html?spaces=blah", td.ioArgs.url);
222
 
                                                                d.callback(true);
223
 
                                                        });
224
 
                                                        return d;
225
 
                                                },
226
 
                                                function xhrPost(t){
227
 
                                                        var d = new doh.Deferred();
228
 
                                                        var td = dojo.xhrPost({
229
 
                                                                url: "xhr.html?foo=bar", // self
230
 
                                                                content: { color: "blue"},
231
 
                                                                handle: function(res, ioArgs){
232
 
                                                                        if((dojo._isDocumentOk(ioArgs.xhr))||
233
 
                                                                                (ioArgs.xhr.status == 405)
234
 
                                                                        ){
235
 
                                                                                d.callback(true);
236
 
                                                                        }else{
237
 
                                                                                d.errback(false);
238
 
                                                                        }                                                               
239
 
                                                                }
240
 
                                                        });
241
 
                                                        // t.t(td instanceof dojo.Deferred);
242
 
                                                        return d;
243
 
                                                },
244
 
                                                function xhrPostWithContent(t){
245
 
                                                        var d = new doh.Deferred();
246
 
                                                        var td = dojo.xhrPost({
247
 
                                                                url: "xhr.html",
248
 
                                                                content: {
249
 
                                                                        foo: [ "bar", "baz" ],
250
 
                                                                        thud: "thonk",
251
 
                                                                        xyzzy: 3
252
 
                                                                }
253
 
                                                        });
254
 
                                                        td.addBoth(function(text){
255
 
                                                                t.is("foo=bar&foo=baz&thud=thonk&xyzzy=3", 
256
 
                                                                                td.ioArgs.query);
257
 
                                                                if(     (dojo._isDocumentOk(td.ioArgs.xhr))||
258
 
                                                                        (td.ioArgs.xhr.status == 405)
259
 
                                                                ){
260
 
                                                                        d.callback(true);
261
 
                                                                }else{
262
 
                                                                        d.errback(false);
263
 
                                                                }
264
 
                                                        });
265
 
                                                        return d;
266
 
                                                },
267
 
                                                function xhrPostForm(t){
268
 
                                                        var d = new doh.Deferred();
269
 
                                                        var form = dojo.byId("f4");
270
 
 
271
 
                                                        //Make sure we can send a form to its 
272
 
                                                        //action URL.   See trac: #2844.
273
 
                                                        var td = dojo.xhrPost({
274
 
                                                                form: form
275
 
                                                        });
276
 
                                                        td.addCallback(function(){
277
 
                                                                d.callback(true);
278
 
                                                        });
279
 
                                                        td.addErrback(function(error){
280
 
                                                                d.callback(error);
281
 
                                                        });
282
 
                                                        // t.t(td instanceof dojo.Deferred);
283
 
                                                        return d;
284
 
                                                },
285
 
                                                function rawXhrPost(t){
286
 
                                                        var d = new doh.Deferred();
287
 
                                                        var td = dojo.rawXhrPost({
288
 
                                                                url: "xhr.html", // self
289
 
                                                                postContent: "foo=bar&color=blue&height=average",
290
 
                                                                handle: function(res, ioArgs){
291
 
                                                                        if((dojo._isDocumentOk(ioArgs.xhr))||
292
 
                                                                                (ioArgs.xhr.status == 405)
293
 
                                                                        ){
294
 
                                                                                d.callback(true);
295
 
                                                                        }else{
296
 
                                                                                d.errback(false);
297
 
                                                                        }                                                               
298
 
                                                                }
299
 
                                                        });
300
 
                                                        // t.t(td instanceof dojo.Deferred);
301
 
                                                        return d;
302
 
                                                },
303
 
                                                function xhrPut(t){
304
 
                                                        var d = new doh.Deferred();
305
 
                                                        var td = dojo.xhrPut({
306
 
                                                                url: "xhrDummyMethod.php?foo=bar", // self
307
 
                                                                content: { color: "blue"},
308
 
                                                                handle: function(res, ioArgs){
309
 
                                                                        if((dojo._isDocumentOk(ioArgs.xhr))||
310
 
                                                                                (ioArgs.xhr.status == 403)
311
 
                                                                        ){
312
 
                                                                                d.callback(true);
313
 
                                                                        }else{
314
 
                                                                                d.errback(false);
315
 
                                                                        }                                                               
316
 
                                                                }
317
 
                                                        });
318
 
                                                        // t.t(td instanceof dojo.Deferred);
319
 
                                                        return d;
320
 
                                                },
321
 
                                                function xhrDelete(t){
322
 
                                                        var d = new doh.Deferred();
323
 
                                                        var td = dojo.xhrDelete({
324
 
                                                                url: "xhrDummyMethod.php", // self
325
 
                                                                preventCache: true,
326
 
                                                                handle: function(res, ioArgs){
327
 
                                                                        if((dojo._isDocumentOk(ioArgs.xhr))||
328
 
                                                                                (ioArgs.xhr.status == 403)
329
 
                                                                        ){
330
 
                                                                                d.callback(true);
331
 
                                                                        }else{
332
 
                                                                                d.errback(false);
333
 
                                                                        }                                                               
334
 
                                                                }
335
 
                                                        });
336
 
                                                        // t.t(td instanceof dojo.Deferred);
337
 
                                                        return d;
338
 
                                                },
339
 
                                                function xhrCancel(t){
340
 
                                                        var d = new doh.Deferred();
341
 
                                                        var td = dojo.xhrPost({
342
 
                                                                url: "xhrDummyMethod.php", // self
343
 
                                                                handle: function(res, ioArgs){
344
 
                                                                        if(res instanceof Error && res.dojoType == "cancel"){
345
 
                                                                                d.callback(true);
346
 
                                                                        }else{
347
 
                                                                                d.errback(false);
348
 
                                                                        }                                                               
349
 
                                                                }
350
 
                                                        });
351
 
                                                        td.cancel();
352
 
                                                        // t.t(td instanceof dojo.Deferred);
353
 
                                                        return d;
354
 
                                                }
355
 
                                                // FIXME: need to add tests for wrapForm
356
 
                                        ]
357
 
                                );
358
 
                                doh.run();
359
 
                        });
360
 
                </script>
361
 
        </head>
362
 
        <body>
363
 
                <form id="f1" style="border: 1px solid black;">
364
 
                        <input type="text" name="blah" value="blah">
365
 
                        <input type="text" name="no_value" value="blah" disabled>
366
 
                        <input type="button" name="no_value2" value="blah">
367
 
                </form>
368
 
                <form id="f2" style="border: 1px solid black;">
369
 
                        <input type="text" name="blah" value="blah">
370
 
                        <input type="text" name="no_value" value="blah" disabled>
371
 
                        <input type="button" name="no_value2" value="blah">
372
 
                        <select type="select" multiple name="multi" size="5">
373
 
                                <option value="blah">blah</option>
374
 
                                <option value="thud" selected>thud</option>
375
 
                                <option value="thonk" selected>thonk</option>
376
 
                        </select>
377
 
                        <textarea name="textarea">textarea_value</textarea>
378
 
                </form>
379
 
                <form id="f3" style="border: 1px solid black;">
380
 
                        <input type="hidden" name="spaces" value="string with spaces">
381
 
                </form>
382
 
                <form id="f4" style="border: 1px solid black;" action="xhrDummyMethod.php">
383
 
                        <input type="hidden" name="action" value="Form with input named action">
384
 
                </form>
385
 
        </body>
386
 
</html>
387