openlayers/tests/Protocol/HTTP.html

   1 <html>
   2 <head>
   3   <script src="../../lib/OpenLayers.js"></script>
   4   <script type="text/javascript">
   5
   6     function test_constructor(t) {
   7         t.plan(8);
   8         var a = new OpenLayers.Protocol.HTTP({
   9             url: "foo"
  10         });
  11
  12         // 4 tests
  13         t.eq(a.url, "foo", "constructor sets url");
  14         t.eq(a.options.url, a.url, "constructor copies url to options.url");
  15         t.eq(a.params, {}, "constructor sets params");
  16         t.eq(a.options.params, undefined, "constructor do not copy params to options.params");
  17
  18         var params = {hello: "world"};
  19         var b = new OpenLayers.Protocol.HTTP({
  20             url: "bar",
  21             params: params
  22         });
  23
  24         // 4 tests
  25         t.eq(b.url, "bar", "constructor sets url");
  26         t.eq(b.options.url, b.url, "constructor copies url to options.url");
  27         t.eq(b.params, params, "constructor sets params");
  28         t.eq(b.options.params, b.params, "constructor copies params to options.params");
  29     }
  30
  31     function test_destroy(t) {
  32         t.plan(3);
  33         var protocol = new OpenLayers.Protocol.HTTP({
  34             url: "bar",
  35             params: {hello: "world"}
  36         });
  37         protocol.destroy();
  38         t.eq(protocol.options, null, "destroy nullifies options");
  39         t.eq(protocol.params, null, "destroy nullifies params");
  40         t.eq(protocol.headers, null, "destroy nullifies headers");
  41     }
  42
  43     function test_read(t) {
  44         t.plan(10);
  45         var protocol = new OpenLayers.Protocol.HTTP({
  46             'url': 'foo_url',
  47             'params': {'k': 'foo_param'}
  48         });
  49
  50         // fake XHR request object
  51         var request = {'status': 200};
  52
  53         // options to pass to read
  54         var readOptions = {
  55             'url': 'bar_url',
  56             'params': {'k': 'bar_param'},
  57             'headers': {'k': 'bar_header'},
  58             'scope': {'hello': 'world'},
  59             'callback': function() {}
  60         };
  61
  62         var response;
  63
  64         protocol.handleResponse = function(resp, opt) {
  65             // 4 tests
  66             var req = resp.priv;
  67             t.ok(this == protocol,
  68                 'handleResponse called with correct scope');
  69             t.ok(opt == readOptions,
  70                 'handleResponse called with correct options');
  71             t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
  72                 'handleResponse called with a Response object');
  73             t.eq(req, request,
  74                 'handleResponse called with correct request');
  75
  76             response = resp;
  77         };
  78
  79         var _get = OpenLayers.Request.GET;
  80
  81         OpenLayers.Request.GET = function(options) {
  82             // 5 tests
  83             t.eq(options.url, readOptions.url,
  84                 'GET called with correct url in options');
  85             t.eq(options.params['k'], readOptions.params['k'],
  86                 'GET called with correct params in options');
  87             t.eq(options.headers['k'], readOptions.headers['k'],
  88                 'GET called with correct headers in options');
  89             t.eq(options.scope, undefined,
  90                 'GET called with correct scope in options');
  91             t.ok(typeof options.callback == 'function',
  92                 'GET called with a callback in options');
  93             t.delay_call(0.1, function() {
  94                 options.callback(request);
  95                 t.ok(resp == response,
  96                     'read returns the expected response object');
  97                 // cleanup
  98                 protocol.destroy();
  99                 OpenLayers.Request.GET = _get;
 100             });
 101             return request;
 102         };
 103
 104         var resp = protocol.read(readOptions);
 105
 106         OpenLayers.Request.GET = _get;
 107     }
 108
 109     function test_readWithPOST(t) {
 110         t.plan(10);
 111         var protocol = new OpenLayers.Protocol.HTTP({
 112             'url': 'foo_url',
 113             'params': {'k': 'foo_param'}
 114         });
 115
 116         // fake XHR request object
 117         var request = {'status': 200};
 118
 119         // options to pass to read
 120         var readOptions = {
 121             'url': 'bar_url',
 122             'params': {'k': 'bar_param'},
 123             'scope': {'hello': 'world'},
 124             'callback': function() {},
 125             'readWithPOST': true
 126         };
 127
 128         var response;
 129
 130         protocol.handleResponse = function(resp, opt) {
 131             // 4 tests
 132             var req = resp.priv;
 133             t.ok(this == protocol,
 134                 'handleResponse called with correct scope');
 135             t.ok(opt == readOptions,
 136                 'handleResponse called with correct options');
 137             t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 138                 'handleResponse called with a Response object');
 139             t.eq(req, request,
 140                 'handleResponse called with correct request');
 141
 142             response = resp;
 143         };
 144
 145         var _post = OpenLayers.Request.POST;
 146
 147         OpenLayers.Request.POST = function(options) {
 148             // 5 tests
 149             t.eq(options.url, readOptions.url,
 150                 'GET with POST called with correct url in options');
 151             t.eq(options.data, OpenLayers.Util.getParameterString(readOptions.params),
 152                 'GET with POST called with correct params encoded in options');
 153             t.eq(options.headers, {"Content-Type": "application/x-www-form-urlencoded"},
 154                 'GET with POST called with correct headers (application/x-www-form-urlencoded)');
 155             t.eq(options.scope, undefined,
 156                 'GET with POST called with correct scope in options');
 157             t.ok(typeof options.callback == 'function',
 158                 'GET with POST called with a callback in options');
 159             t.delay_call(0.1, function() {
 160                 options.callback(request);
 161                 t.ok(resp == response,
 162                     'read returns the expected response object');
 163                 // cleanup
 164                 protocol.destroy();
 165                 OpenLayers.Request.POST = _post;
 166             });
 167             return request;
 168         };
 169
 170         var resp = protocol.read(readOptions);
 171
 172         OpenLayers.Request.POST = _post;
 173     }
 174
 175     function test_read_method(t) {
 176         t.plan(4);
 177
 178         var _post = OpenLayers.Request.POST;
 179         OpenLayers.Request.POST = function(options) { return 'post'; }
 180         var _get = OpenLayers.Request.GET;
 181         OpenLayers.Request.GET = function(options) { return 'get'; }
 182
 183         var protocol = new OpenLayers.Protocol.HTTP({});
 184
 185         t.eq(protocol.read({}).priv, 'get',
 186             'readWithPOST is false by default');
 187         t.eq(protocol.read({readWithPOST: true}).priv, 'post',
 188             'readWithPOST can be set in read options');
 189
 190         var protocol = new OpenLayers.Protocol.HTTP({readWithPOST: true});
 191
 192         t.eq(protocol.read({}).priv, 'post',
 193             'readWithPOST can be set in constructor');
 194         t.eq(protocol.read({readWithPOST: false}).priv, 'get',
 195             'readWithPOST can be overridden in read options');
 196
 197         OpenLayers.Request.POST = _post;
 198         OpenLayers.Request.GET = _get;
 199     }
 200
 201     function test_read_bbox(t) {
 202         t.plan(1);
 203         var protocol = new OpenLayers.Protocol.HTTP();
 204
 205         // fake XHR request object
 206         var request = {'status': 200};
 207
 208         var _get = OpenLayers.Request.GET;
 209
 210         var bounds = new OpenLayers.Bounds(1, 2, 3, 4);
 211         var filter = new OpenLayers.Filter.Spatial({
 212             type: OpenLayers.Filter.Spatial.BBOX,
 213             value: bounds,
 214             projection: "foo"
 215         });
 216
 217         OpenLayers.Request.GET = function(options) {
 218             t.eq(options.params['bbox'].toString(), bounds.toArray().toString(),
 219                 'GET called with bbox filter in params');
 220             return request;
 221         };
 222
 223         var resp = protocol.read({filter: filter});
 224
 225         OpenLayers.Request.GET = _get;
 226     }
 227
 228     function test_parseFeatures(t) {
 229         t.plan(5);
 230
 231         var protocol = new OpenLayers.Protocol.HTTP();
 232
 233         // test responseXML - 2 tests
 234         var request = {
 235             'responseXML': {
 236                 'documentElement': 'xml'
 237             }
 238         };
 239         protocol.format = {
 240             'read': function(doc) {
 241                 t.eq(doc.documentElement, 'xml',
 242                     'format.read called with correct doc');
 243                 return doc.documentElement;
 244             }
 245         };
 246         var ret = protocol.parseFeatures(request);
 247         t.eq(ret, 'xml', 'parseFeatures returns expected value');
 248
 249         // test responseText - 2 tests
 250         var request = {
 251             'responseText': 'text'
 252         };
 253         protocol.format = {
 254             'read': function(doc) {
 255                 t.eq(doc, 'text',
 256                     'format.read called with correct doc');
 257                 return doc;
 258             }
 259         };
 260         var ret = protocol.parseFeatures(request);
 261         t.eq(ret, 'text', 'parseFeatures returns expected value');
 262
 263         // test empty responseText - 1 test
 264         var request = {
 265             'responseText': ''
 266         };
 267         protocol.format = {
 268             'read': function(doc) {
 269                 t.fail('format.read should not be called');
 270             }
 271         };
 272         var ret = protocol.parseFeatures(request);
 273         t.eq(ret, null, 'parseFeatures returns expected value');
 274     }
 275
 276     function test_create(t) {
 277         t.plan(10);
 278         var protocol = new OpenLayers.Protocol.HTTP({
 279             'url': 'foo_url',
 280             'format': {'write': function() {}}
 281         });
 282
 283         // fake XHR request object
 284         var request = {'status': 200};
 285
 286         // features to pass to create
 287         var features = ['feature'];
 288
 289         // options to pass to create
 290         var createOptions = {
 291             'url': 'bar_url',
 292             'headers': {'k': 'bar_header'},
 293             'scope': {'hello': 'world'},
 294             'callback': function() {}
 295         };
 296
 297         var response;
 298
 299         protocol.handleCreate = function(resp, opt) {
 300             // 5 tests
 301             var req = resp.priv;
 302             t.ok(this == protocol,
 303                 'handleCreate called with correct scope');
 304             t.ok(opt == createOptions,
 305                 'handleCreate called with correct options');
 306             t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 307                 'handleCreate called with a Response object');
 308             t.ok(resp.reqFeatures == features,
 309                 'handleCreate called with correct requested features in response');
 310             t.eq(req, request,
 311                 'handleCreate called with correct request');
 312
 313             response = resp;
 314         };
 315
 316         var _post = OpenLayers.Request.POST;
 317
 318         OpenLayers.Request.POST = function(options) {
 319             // 4 tests
 320             t.eq(options.url, createOptions.url,
 321                 'POST called with correct url in options');
 322             t.eq(options.headers['k'], createOptions.headers['k'],
 323                 'POST called with correct headers in options');
 324             t.eq(options.scope, undefined,
 325                 'POST called with correct scope in options');
 326             t.ok(typeof options.callback == 'function',
 327                 'POST called with a callback in options');
 328             // call callback - delayed because this function has to return first
 329             t.delay_call(0.1, function() {
 330                 options.callback(request);
 331                 t.ok(resp == response,
 332                     'create returns the expected response object');
 333                 // cleanup
 334                 protocol.destroy();
 335                 OpenLayers.Request.POST = _post;
 336             });
 337             return request;
 338         };
 339
 340         var resp = protocol.create(features, createOptions);
 341
 342         OpenLayers.Request.POST = _post;
 343     }
 344
 345     function test_update(t) {
 346         t.plan(10);
 347         var protocol = new OpenLayers.Protocol.HTTP({
 348             'url': 'foo_url',
 349             'format': {'write': function() {}}
 350         });
 351
 352         // fake XHR request object
 353         var request = {'status': 200};
 354
 355         // feature to pass to update
 356         var feature = {'feature':'feature'};
 357
 358         // options to pass to update
 359         var updateOptions = {
 360             'url': 'bar_url',
 361             'headers': {'k': 'bar_header'},
 362             'scope': {'hello': 'world'},
 363             'callback': function() {}
 364         };
 365
 366         var response;
 367
 368         protocol.handleUpdate = function(resp, opt) {
 369             var req = resp.priv;
 370             // 5 tests
 371             t.ok(this == protocol,
 372                 'handleUpdate called with correct scope');
 373             t.ok(opt == updateOptions,
 374                 'handleUpdate called with correct options');
 375             t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 376                 'handleUpdate called with a Response object');
 377             t.ok(resp.reqFeatures == feature,
 378                 'handleUpdate called with correct requested feature in response');
 379             t.eq(req, request,
 380                 'handleUpdate called with correct request');
 381
 382             response = resp;
 383         };
 384
 385         var _put = OpenLayers.Request.PUT;
 386
 387         OpenLayers.Request.PUT = function(options) {
 388             // 4 tests
 389             t.eq(options.url, updateOptions.url,
 390                 'PUT called with correct url in options');
 391             t.eq(options.headers['k'], updateOptions.headers['k'],
 392                 'PUT called with correct headers in options');
 393             t.eq(options.scope, undefined,
 394                 'PUT called with correct scope in options');
 395             t.ok(typeof options.callback == 'function',
 396                 'PUT called with a callback in options');
 397             // call callback - delayed because this function has to return first
 398             t.delay_call(0.1, function() {
 399                 options.callback(request);
 400                 t.ok(resp == response,
 401                     'update returns the expected response object');
 402                 // cleanup
 403                 protocol.destroy();
 404                 OpenLayers.Request.PUT = _put;
 405             });
 406             return request;
 407         };
 408
 409         var resp = protocol.update(feature, updateOptions);
 410
 411         OpenLayers.Request.PUT = _put;
 412     }
 413
 414     function test_handleResponse(t) {
 415         t.plan(6);
 416
 417         var protocol = new OpenLayers.Protocol.HTTP();
 418
 419         var options, response, request, features;
 420
 421         // test options - 2 tests
 422         var scope = {'fake': 'scope'};
 423         options = {
 424             'scope': scope,
 425             'callback': function(resp) {
 426                 t.ok(this == scope,
 427                     '[no status] callback called with correct scope');
 428                 t.ok(resp == response,
 429                     '[no status] callback called with correct response');
 430             }
 431         };
 432         response = {priv: {}};
 433         protocol.handleResponse(response, options);
 434
 435         // test failure condition - 1 test
 436         options = {
 437             'callback': function(resp) {
 438                 t.eq(resp.code, OpenLayers.Protocol.Response.FAILURE,
 439                     '[status 400] callback called with correct response code');
 440             }
 441         };
 442         response = {priv: {status: 400}};
 443         protocol.handleResponse(response, options);
 444
 445         // test success condition - 3 tests
 446         features = {'fake': 'features'};
 447         options = {
 448             'callback': function(resp) {
 449                 t.eq(resp.code, OpenLayers.Protocol.Response.SUCCESS,
 450                     '[status 200] callback called with correct response code');
 451                 t.eq(resp.features, features,
 452                     '[status 200] callback called with correct features in response');
 453             }
 454         };
 455         response = {priv: {status: 200}};
 456         protocol.parseFeatures = function(request) {
 457             t.ok(request == response.priv,
 458                 '[status 200] parseFeatures called with correct request');
 459             return features;
 460         }
 461         protocol.handleResponse(response, options);
 462
 463         // cleanup
 464         protocol.destroy();
 465     }
 466
 467     function test_delete(t) {
 468         t.plan(10);
 469         var protocol = new OpenLayers.Protocol.HTTP({
 470             'url': 'foo_url'
 471         });
 472
 473         // fake XHR request object
 474         var request = {'status': 200};
 475
 476         // feature to pass to delete
 477         var feature = {'url': 'bar_url'};
 478
 479         // options to pass to delete
 480         var deleteOptions = {
 481             'url': 'bar_url',
 482             'headers': {'k': 'bar_header'},
 483             'scope': {'hello': 'world'},
 484             'callback': function() {}
 485         };
 486
 487         var response;
 488
 489         protocol.handleDelete = function(resp, opt) {
 490             // 5 tests
 491             var req = resp.priv;
 492             t.ok(this == protocol,
 493                 'handleDelete called with correct scope');
 494             t.ok(opt == deleteOptions,
 495                 'handleDelete called with correct options');
 496             t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 497                 'handleDelete called with a Response object');
 498             t.ok(resp.reqFeatures == feature,
 499                 'handleDelete called with correct requested feature in response');
 500             t.eq(req, request,
 501                 'handleDelete called with correct request');
 502
 503             response = resp;
 504         };
 505
 506         var _delete = OpenLayers.Request.DELETE;
 507
 508         OpenLayers.Request.DELETE = function(options) {
 509             // 4 tests
 510             t.eq(options.url, deleteOptions.url,
 511                 'DELETE called with correct url in options');
 512             t.eq(options.headers['k'], deleteOptions.headers['k'],
 513                 'DELETE called with correct headers in options');
 514             t.eq(options.scope, undefined,
 515                 'DELETE called with correct scope in options');
 516             t.ok(typeof options.callback == 'function',
 517                 'DELETE called with a callback in options');
 518             // call callback - delayed because this function has to return first
 519             t.delay_call(0.1, function() {
 520                 options.callback(request);
 521                 t.ok(resp == response,
 522                     'read returns the expected response object');
 523                 // cleanup
 524                 protocol.destroy();
 525                 OpenLayers.Request.DELETE = _delete;
 526             });
 527             return request;
 528         };
 529
 530         var resp = protocol['delete'](feature, deleteOptions);
 531
 532         OpenLayers.Request.DELETE = _delete;
 533     }
 534
 535     function test_handleDelete(t) {
 536         t.plan(4);
 537
 538         var protocol = new OpenLayers.Protocol.HTTP();
 539
 540         var options, response, request, features;
 541
 542         // test options - 2 tests
 543         var scope = {'fake': 'scope'};
 544         options = {
 545             'scope': scope,
 546             'callback': function(resp) {
 547                 t.ok(this == scope,
 548                     'callback called with correct scope');
 549                 t.ok(resp == response,
 550                     'callback called with correct response');
 551             }
 552         };
 553         response = {priv: {}};
 554         protocol.handleDelete(response, options);
 555
 556         // test failure condition - 1 test
 557         options = {
 558             'callback': function(resp) {
 559                 t.eq(resp.code, OpenLayers.Protocol.Response.FAILURE,
 560                     'callback called with correct response code');
 561             }
 562         };
 563         response = {priv: {status: 400}};
 564         protocol.handleDelete(response, options);
 565
 566         // test success condition - 1 test
 567         options = {
 568             'callback': function(resp) {
 569                 t.eq(resp.code, OpenLayers.Protocol.Response.SUCCESS,
 570                     'callback called with correct response code');
 571             }
 572         };
 573         response = {priv: {status: 200}};
 574         protocol.handleDelete(response, options);
 575
 576         // cleanup
 577         protocol.destroy();
 578     }
 579
 580     function test_commit(t) {
 581         t.plan(17);
 582
 583         var protocol = new OpenLayers.Protocol.HTTP();
 584
 585         // 6 features
 586         var features = [
 587             {'state': OpenLayers.State.INSERT},
 588             {'state': OpenLayers.State.INSERT},
 589             {'state': OpenLayers.State.UPDATE},
 590             {'state': OpenLayers.State.UPDATE},
 591             {'state': OpenLayers.State.DELETE},
 592             {'state': OpenLayers.State.DELETE}
 593         ];
 594
 595         var options = {
 596             'create': {
 597                 'callback': function(resp) {
 598                 }
 599             },
 600             'update': {
 601                 'callback': function(resp) {
 602                 }
 603             },
 604             'delete': {
 605                 'callback': function(resp) {
 606                 }
 607             }
 608         };
 609
 610         var respCreate = new OpenLayers.Protocol.Response();
 611         var respUpdate = new OpenLayers.Protocol.Response();
 612         var respDelete = new OpenLayers.Protocol.Response();
 613
 614         // 2 tests
 615         protocol['create'] = function(feature, options) {
 616             t.ok(options.scope == protocol,
 617                 'create called with correct scope');
 618             t.ok(typeof options.callback == 'function',
 619                 'create called with a callback in options');
 620             options.callback.call(options.scope, respCreate);
 621             return respCreate;
 622         };
 623         // 4 tests
 624         protocol['update'] = function(feature, options) {
 625             t.ok(options.scope == protocol,
 626                 'update called with correct scope');
 627             t.ok(typeof options.callback == 'function',
 628                 'update called with a callback in options');
 629             options.callback.call(options.scope, respUpdate);
 630             return respUpdate;
 631         };
 632         // 4 tests
 633         protocol['delete'] = function(feature, options) {
 634             t.ok(options.scope == protocol,
 635                 'delete called with correct scope');
 636             t.ok(typeof options.callback == 'function',
 637                 'delete called with a callback in options');
 638             options.callback.call(options.scope, respDelete);
 639             return respDelete;
 640         };
 641
 642         var count = 0;
 643
 644         // 5 tests
 645         protocol.callUserCallback = function(resp, opt) {
 646             t.ok(opt == options,
 647                 'callUserCallback called with correction options map');
 648             count++;
 649         };
 650
 651         var resp = protocol.commit(features, options);
 652
 653         // 2 tests
 654         t.eq(count, 5, 'callUserCallback called for each request');
 655         t.eq(resp.length, 5, 'commit returns array with correct length');
 656
 657         // cleanup
 658         protocol.destroy();
 659     }
 660
 661     function test_callUserCallback(t) {
 662         t.plan(1);
 663
 664         var protocol = new OpenLayers.Protocol.HTTP();
 665
 666         var scope = {'fake': 'scope'};
 667
 668         // test commit callback
 669         var log = {};
 670         var options = {
 671             foo: {
 672                 callback: function() {
 673                     log.scope = this;
 674                 },
 675                 scope: scope
 676             }
 677         };
 678         var resp = {requestType: 'foo'};
 679         protocol.callUserCallback(resp, options);
 680         t.ok(log.scope, scope, 'correct callback called with correct scope');
 681
 682     }
 683
 684     function test_options(t) {
 685         t.plan(6);
 686
 687         var log1 = {};
 688
 689         // test that read with no options uses protocol options - 5 tests
 690         var url = ".";
 691         var headers = {};
 692         var params = {};
 693         var scope = {};
 694         var protocol = new OpenLayers.Protocol.HTTP({
 695             format: new OpenLayers.Format({
 696                 read: function() {},
 697                 write: function() {}
 698             }),
 699             url: url,
 700             headers: headers,
 701             params: params,
 702             callback: function(resp) {
 703                 log1.callbackCalled = true;
 704                 log1.callbackScope = this;
 705                 log1.request = resp && resp.priv;
 706                 log1.requestType = resp && resp.requestType;
 707             },
 708             scope: scope
 709         });
 710         protocol.read();
 711
 712         t.delay_call(0.5, function() {
 713             t.eq(log1.callbackCalled, true, "[read] callback called");
 714             t.eq(log1.callbackScope, scope, "[read] correct scope");
 715             t.ok(log1.request instanceof OpenLayers.Request.XMLHttpRequest, "[read] correct priv type");
 716             t.eq(log1.requestType, "read", "[read] correct request type");
 717         });
 718
 719
 720         // test that commit with no options uses protocol options - 2 tests
 721         var log2 = {called: 0};
 722         protocol.options.callback = function() {
 723             log2.called++;
 724             log2.scope = this;
 725         };
 726         protocol.commit([
 727             {state: OpenLayers.State.INSERT},
 728             {state: OpenLayers.State.INSERT},
 729             {state: OpenLayers.State.UPDATE, url: "./1"},
 730             {state: OpenLayers.State.UPDATE, url: "./2"},
 731             {state: OpenLayers.State.DELETE, url: "./3"},
 732             {state: OpenLayers.State.DELETE, url: "./4"}
 733         ]);
 734         t.delay_call(0.5, function() {
 735             t.eq(log2.called, 1, "[commit] Callback called once.");
 736             t.eq(log2.scope, scope, "[commit] Correct scope.");
 737         });
 738
 739     }
 740
 741
 742   </script>
 743 </head>
 744 <body>
 745 </body>
 746 </html>