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