← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/tests/Protocol/HTTP.html

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/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_read_bbox(t) {
 
110
        t.plan(1);
 
111
        var protocol = new OpenLayers.Protocol.HTTP();
 
112
 
 
113
        // fake XHR request object
 
114
        var request = {'status': 200};
 
115
 
 
116
        var _get = OpenLayers.Request.GET;
 
117
 
 
118
        var bounds = new OpenLayers.Bounds(1, 2, 3, 4);
 
119
        var filter = new OpenLayers.Filter.Spatial({
 
120
            type: OpenLayers.Filter.Spatial.BBOX,
 
121
            value: bounds,
 
122
            projection: "foo"
 
123
        });
 
124
        
 
125
        OpenLayers.Request.GET = function(options) {
 
126
            t.eq(options.params['bbox'].toString(), bounds.toArray().toString(),
 
127
                'GET called with bbox filter in params');
 
128
            return request;
 
129
        };
 
130
 
 
131
        var resp = protocol.read({filter: filter});
 
132
 
 
133
        OpenLayers.Request.GET = _get;        
 
134
    }
 
135
 
 
136
    function test_parseFeatures(t) {
 
137
        t.plan(5);
 
138
 
 
139
        var protocol = new OpenLayers.Protocol.HTTP();
 
140
 
 
141
        // test responseXML - 2 tests
 
142
        var request = {
 
143
            'responseXML': {
 
144
                'documentElement': 'xml'
 
145
            }
 
146
        };
 
147
        protocol.format = {
 
148
            'read': function(doc) {
 
149
                t.eq(doc.documentElement, 'xml',
 
150
                    'format.read called with correct doc');
 
151
                return doc.documentElement;
 
152
            }
 
153
        };
 
154
        var ret = protocol.parseFeatures(request);
 
155
        t.eq(ret, 'xml', 'parseFeatures returns expected value');
 
156
 
 
157
        // test responseText - 2 tests
 
158
        var request = {
 
159
            'responseText': 'text'
 
160
        };
 
161
        protocol.format = {
 
162
            'read': function(doc) {
 
163
                t.eq(doc, 'text',
 
164
                    'format.read called with correct doc');
 
165
                return doc;
 
166
            }
 
167
        };
 
168
        var ret = protocol.parseFeatures(request);
 
169
        t.eq(ret, 'text', 'parseFeatures returns expected value');
 
170
 
 
171
        // test empty responseText - 1 test
 
172
        var request = {
 
173
            'responseText': ''
 
174
        };
 
175
        protocol.format = {
 
176
            'read': function(doc) {
 
177
                t.fail('format.read should not be called');
 
178
            }
 
179
        };
 
180
        var ret = protocol.parseFeatures(request);
 
181
        t.eq(ret, null, 'parseFeatures returns expected value');
 
182
    }
 
183
 
 
184
    function test_create(t) {
 
185
        t.plan(10);
 
186
        var protocol = new OpenLayers.Protocol.HTTP({
 
187
            'url': 'foo_url',
 
188
            'format': {'write': function() {}}
 
189
        });
 
190
 
 
191
        // fake XHR request object
 
192
        var request = {'status': 200};
 
193
 
 
194
        // features to pass to create
 
195
        var features = ['feature'];
 
196
 
 
197
        // options to pass to create
 
198
        var createOptions = {
 
199
            'url': 'bar_url',
 
200
            'headers': {'k': 'bar_header'},
 
201
            'scope': {'hello': 'world'},
 
202
            'callback': function() {}
 
203
        };
 
204
 
 
205
        var response;
 
206
 
 
207
        protocol.handleCreate = function(resp, opt) {
 
208
            // 5 tests
 
209
            var req = resp.priv;
 
210
            t.ok(this == protocol,
 
211
                'handleCreate called with correct scope');
 
212
            t.ok(opt == createOptions,
 
213
                'handleCreate called with correct options');
 
214
            t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 
215
                'handleCreate called with a Response object');
 
216
            t.ok(resp.reqFeatures == features,
 
217
                'handleCreate called with correct requested features in response');
 
218
            t.eq(req, request,
 
219
                'handleCreate called with correct request');
 
220
 
 
221
            response = resp;
 
222
        };
 
223
 
 
224
        var _post = OpenLayers.Request.POST;
 
225
 
 
226
        OpenLayers.Request.POST = function(options) {
 
227
            // 4 tests
 
228
            t.eq(options.url, createOptions.url,
 
229
                'POST called with correct url in options');
 
230
            t.eq(options.headers['k'], createOptions.headers['k'],
 
231
                'POST called with correct headers in options');
 
232
            t.eq(options.scope, undefined,
 
233
                'POST called with correct scope in options');
 
234
            t.ok(typeof options.callback == 'function',
 
235
                'POST called with a callback in options');
 
236
            // call callback - delayed because this function has to return first
 
237
            t.delay_call(0.1, function() {
 
238
                options.callback(request);
 
239
                t.ok(resp == response,
 
240
                    'create returns the expected response object');
 
241
                // cleanup
 
242
                protocol.destroy();
 
243
                OpenLayers.Request.POST = _post;
 
244
            });
 
245
            return request;
 
246
        };
 
247
 
 
248
        var resp = protocol.create(features, createOptions);
 
249
        
 
250
        OpenLayers.Request.POST = _post;
 
251
    }
 
252
 
 
253
    function test_update(t) {
 
254
        t.plan(10);
 
255
        var protocol = new OpenLayers.Protocol.HTTP({
 
256
            'url': 'foo_url',
 
257
            'format': {'write': function() {}}
 
258
        });
 
259
 
 
260
        // fake XHR request object
 
261
        var request = {'status': 200};
 
262
 
 
263
        // feature to pass to update
 
264
        var feature = {'feature':'feature'};
 
265
 
 
266
        // options to pass to update
 
267
        var updateOptions = {
 
268
            'url': 'bar_url',
 
269
            'headers': {'k': 'bar_header'},
 
270
            'scope': {'hello': 'world'},
 
271
            'callback': function() {}
 
272
        };
 
273
 
 
274
        var response;
 
275
 
 
276
        protocol.handleUpdate = function(resp, opt) {
 
277
            var req = resp.priv;
 
278
            // 5 tests
 
279
            t.ok(this == protocol,
 
280
                'handleUpdate called with correct scope');
 
281
            t.ok(opt == updateOptions,
 
282
                'handleUpdate called with correct options');
 
283
            t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 
284
                'handleUpdate called with a Response object');
 
285
            t.ok(resp.reqFeatures == feature,
 
286
                'handleUpdate called with correct requested feature in response');
 
287
            t.eq(req, request,
 
288
                'handleUpdate called with correct request');
 
289
 
 
290
            response = resp;
 
291
        };
 
292
 
 
293
        var _put = OpenLayers.Request.PUT;
 
294
 
 
295
        OpenLayers.Request.PUT = function(options) {
 
296
            // 4 tests
 
297
            t.eq(options.url, updateOptions.url,
 
298
                'PUT called with correct url in options');
 
299
            t.eq(options.headers['k'], updateOptions.headers['k'],
 
300
                'PUT called with correct headers in options');
 
301
            t.eq(options.scope, undefined,
 
302
                'PUT called with correct scope in options');
 
303
            t.ok(typeof options.callback == 'function',
 
304
                'PUT called with a callback in options');
 
305
            // call callback - delayed because this function has to return first
 
306
            t.delay_call(0.1, function() {
 
307
                options.callback(request);
 
308
                t.ok(resp == response,
 
309
                    'update returns the expected response object');
 
310
                // cleanup
 
311
                protocol.destroy();
 
312
                OpenLayers.Request.PUT = _put;
 
313
            });
 
314
            return request;
 
315
        };
 
316
 
 
317
        var resp = protocol.update(feature, updateOptions);
 
318
        
 
319
        OpenLayers.Request.PUT = _put;
 
320
    }
 
321
 
 
322
    function test_handleResponse(t) {
 
323
        t.plan(6);
 
324
 
 
325
        var protocol = new OpenLayers.Protocol.HTTP();
 
326
 
 
327
        var options, response, request, features;
 
328
 
 
329
        // test options - 2 tests
 
330
        var scope = {'fake': 'scope'};
 
331
        options = {
 
332
            'scope': scope,
 
333
            'callback': function(resp) {
 
334
                t.ok(this == scope,
 
335
                    '[no status] callback called with correct scope');
 
336
                t.ok(resp == response,
 
337
                    '[no status] callback called with correct response');
 
338
            }
 
339
        };
 
340
        response = {priv: {}};
 
341
        protocol.handleResponse(response, options);
 
342
        
 
343
        // test failure condition - 1 test
 
344
        options = {
 
345
            'callback': function(resp) {
 
346
                t.eq(resp.code, OpenLayers.Protocol.Response.FAILURE,
 
347
                    '[status 400] callback called with correct response code');
 
348
            }
 
349
        };
 
350
        response = {priv: {status: 400}};
 
351
        protocol.handleResponse(response, options);
 
352
 
 
353
        // test success condition - 3 tests
 
354
        features = {'fake': 'features'};
 
355
        options = {
 
356
            'callback': function(resp) {
 
357
                t.eq(resp.code, OpenLayers.Protocol.Response.SUCCESS,
 
358
                    '[status 200] callback called with correct response code');
 
359
                t.eq(resp.features, features,
 
360
                    '[status 200] callback called with correct features in response');
 
361
            }
 
362
        };
 
363
        response = {priv: {status: 200}};
 
364
        protocol.parseFeatures = function(request) {
 
365
            t.ok(request == response.priv,
 
366
                '[status 200] parseFeatures called with correct request');
 
367
            return features;
 
368
        }
 
369
        protocol.handleResponse(response, options);
 
370
 
 
371
        // cleanup
 
372
        protocol.destroy();
 
373
    }
 
374
 
 
375
    function test_delete(t) {
 
376
        t.plan(10);
 
377
        var protocol = new OpenLayers.Protocol.HTTP({
 
378
            'url': 'foo_url'
 
379
        });
 
380
 
 
381
        // fake XHR request object
 
382
        var request = {'status': 200};
 
383
 
 
384
        // feature to pass to delete
 
385
        var feature = {'url': 'bar_url'};
 
386
 
 
387
        // options to pass to delete
 
388
        var deleteOptions = {
 
389
            'url': 'bar_url',
 
390
            'headers': {'k': 'bar_header'},
 
391
            'scope': {'hello': 'world'},
 
392
            'callback': function() {}
 
393
        };
 
394
 
 
395
        var response;
 
396
 
 
397
        protocol.handleDelete = function(resp, opt) {
 
398
            // 5 tests
 
399
            var req = resp.priv;
 
400
            t.ok(this == protocol,
 
401
                'handleDelete called with correct scope');
 
402
            t.ok(opt == deleteOptions,
 
403
                'handleDelete called with correct options');
 
404
            t.eq(resp.CLASS_NAME, 'OpenLayers.Protocol.Response',
 
405
                'handleDelete called with a Response object');
 
406
            t.ok(resp.reqFeatures == feature,
 
407
                'handleDelete called with correct requested feature in response');
 
408
            t.eq(req, request,
 
409
                'handleDelete called with correct request');
 
410
 
 
411
            response = resp;
 
412
        };
 
413
 
 
414
        var _delete = OpenLayers.Request.DELETE;
 
415
 
 
416
        OpenLayers.Request.DELETE = function(options) {
 
417
            // 4 tests
 
418
            t.eq(options.url, deleteOptions.url,
 
419
                'DELETE called with correct url in options');
 
420
            t.eq(options.headers['k'], deleteOptions.headers['k'],
 
421
                'DELETE called with correct headers in options');
 
422
            t.eq(options.scope, undefined,
 
423
                'DELETE called with correct scope in options');
 
424
            t.ok(typeof options.callback == 'function',
 
425
                'DELETE called with a callback in options');
 
426
            // call callback - delayed because this function has to return first
 
427
            t.delay_call(0.1, function() {
 
428
                options.callback(request);
 
429
                t.ok(resp == response,
 
430
                    'read returns the expected response object');
 
431
                // cleanup
 
432
                protocol.destroy();
 
433
                OpenLayers.Request.DELETE = _delete;
 
434
            });
 
435
            return request;
 
436
        };
 
437
 
 
438
        var resp = protocol['delete'](feature, deleteOptions);
 
439
 
 
440
        OpenLayers.Request.DELETE = _delete;
 
441
    }
 
442
 
 
443
    function test_handleDelete(t) {
 
444
        t.plan(4);
 
445
 
 
446
        var protocol = new OpenLayers.Protocol.HTTP();
 
447
 
 
448
        var options, response, request, features;
 
449
 
 
450
        // test options - 2 tests
 
451
        var scope = {'fake': 'scope'};
 
452
        options = {
 
453
            'scope': scope,
 
454
            'callback': function(resp) {
 
455
                t.ok(this == scope,
 
456
                    'callback called with correct scope');
 
457
                t.ok(resp == response,
 
458
                    'callback called with correct response');
 
459
            }
 
460
        };
 
461
        response = {priv: {}};
 
462
        protocol.handleDelete(response, options);
 
463
        
 
464
        // test failure condition - 1 test
 
465
        options = {
 
466
            'callback': function(resp) {
 
467
                t.eq(resp.code, OpenLayers.Protocol.Response.FAILURE,
 
468
                    'callback called with correct response code');
 
469
            }
 
470
        };
 
471
        response = {priv: {status: 400}};
 
472
        protocol.handleDelete(response, options);
 
473
 
 
474
        // test success condition - 1 test
 
475
        options = {
 
476
            'callback': function(resp) {
 
477
                t.eq(resp.code, OpenLayers.Protocol.Response.SUCCESS,
 
478
                    'callback called with correct response code');
 
479
            }
 
480
        };
 
481
        response = {priv: {status: 200}};
 
482
        protocol.handleDelete(response, options);
 
483
 
 
484
        // cleanup
 
485
        protocol.destroy();
 
486
    }
 
487
 
 
488
    function test_commit(t) {
 
489
        t.plan(17);
 
490
 
 
491
        var protocol = new OpenLayers.Protocol.HTTP();
 
492
 
 
493
        // 6 features
 
494
        var features = [
 
495
            {'state': OpenLayers.State.INSERT},
 
496
            {'state': OpenLayers.State.INSERT},
 
497
            {'state': OpenLayers.State.UPDATE},
 
498
            {'state': OpenLayers.State.UPDATE},
 
499
            {'state': OpenLayers.State.DELETE},
 
500
            {'state': OpenLayers.State.DELETE}
 
501
        ];
 
502
 
 
503
        var options = {
 
504
            'create': {
 
505
                'callback': function(resp) {
 
506
                }
 
507
            },
 
508
            'update': {
 
509
                'callback': function(resp) {
 
510
                }
 
511
            },
 
512
            'delete': {
 
513
                'callback': function(resp) {
 
514
                }
 
515
            }
 
516
        };
 
517
 
 
518
        var respCreate = new OpenLayers.Protocol.Response();
 
519
        var respUpdate = new OpenLayers.Protocol.Response();
 
520
        var respDelete = new OpenLayers.Protocol.Response();
 
521
 
 
522
        // 2 tests
 
523
        protocol['create'] = function(feature, options) {
 
524
            t.ok(options.scope == protocol,
 
525
                'create called with correct scope');
 
526
            t.ok(typeof options.callback == 'function',
 
527
                'create called with a callback in options');
 
528
            options.callback.call(options.scope, respCreate);
 
529
            return respCreate;
 
530
        };
 
531
        // 4 tests
 
532
        protocol['update'] = function(feature, options) {
 
533
            t.ok(options.scope == protocol,
 
534
                'update called with correct scope');
 
535
            t.ok(typeof options.callback == 'function',
 
536
                'update called with a callback in options');
 
537
            options.callback.call(options.scope, respUpdate);
 
538
            return respUpdate;
 
539
        };
 
540
        // 4 tests
 
541
        protocol['delete'] = function(feature, options) {
 
542
            t.ok(options.scope == protocol,
 
543
                'delete called with correct scope');
 
544
            t.ok(typeof options.callback == 'function',
 
545
                'delete called with a callback in options');
 
546
            options.callback.call(options.scope, respDelete);
 
547
            return respDelete;
 
548
        };
 
549
 
 
550
        var count = 0;
 
551
 
 
552
        // 5 tests
 
553
        protocol.callUserCallback = function(resp, opt) {
 
554
            t.ok(opt == options,
 
555
                'callUserCallback called with correction options map');
 
556
            count++;
 
557
        };
 
558
 
 
559
        var resp = protocol.commit(features, options);
 
560
 
 
561
        // 2 tests
 
562
        t.eq(count, 5, 'callUserCallback called for each request');
 
563
        t.eq(resp.length, 5, 'commit returns array with correct length');
 
564
 
 
565
        // cleanup
 
566
        protocol.destroy();
 
567
    }
 
568
 
 
569
    function test_callUserCallback(t) {
 
570
        t.plan(6);
 
571
 
 
572
        var protocol = new OpenLayers.Protocol.HTTP();
 
573
 
 
574
        var options, resp;
 
575
        var scope = {'fake': 'scope'};
 
576
 
 
577
        // test commit callback
 
578
        // 1 tests
 
579
        options = {
 
580
            'callback': function() {
 
581
                t.ok(this == scope, 'callback called with correct scope');
 
582
            },
 
583
            'scope': scope
 
584
        };
 
585
        resp = {'requestType': 'create', 'last': true};
 
586
        protocol.callUserCallback(resp, options);
 
587
        // 0 test
 
588
        resp = {'requestType': 'create', 'last': false};
 
589
        protocol.callUserCallback(resp, options);
 
590
 
 
591
        // test create callback
 
592
        // 2 tests
 
593
        options = {
 
594
            'create': {
 
595
                'callback': function(r) {
 
596
                    t.ok(this == scope, 'callback called with correct scope');
 
597
                    t.ok(r == resp, 'callback called with correct response');
 
598
                },
 
599
                'scope': scope
 
600
            }
 
601
        };
 
602
        resp = {'requestType': 'create'};
 
603
        protocol.callUserCallback(resp, options);
 
604
 
 
605
        // test with both callbacks set
 
606
        // 3 tests
 
607
        options = {
 
608
            'create': {
 
609
                'callback': function(r) {
 
610
                    t.ok(this == scope, 'callback called with correct scope');
 
611
                    t.ok(r == resp, 'callback called with correct response');
 
612
                },
 
613
                'scope': scope
 
614
            },
 
615
            'callback': function() {
 
616
                t.ok(this == scope, 'callback called with correct scope');
 
617
            },
 
618
            'scope': scope
 
619
        };
 
620
        resp = {'requestType': 'create', 'last': true};
 
621
        protocol.callUserCallback(resp, options);
 
622
 
 
623
        // no callback set
 
624
        // 0 test
 
625
        options = {
 
626
            'delete': {
 
627
                'callback': function(resp) {
 
628
                    t.fail('callback should not get called');
 
629
                }
 
630
            }
 
631
        };
 
632
        resp = {'requestType': 'create'};
 
633
        protocol.callUserCallback(resp, options);
 
634
 
 
635
        // cleanup
 
636
        protocol.destroy();
 
637
    }
 
638
 
 
639
    function test_options(t) {
 
640
        t.plan(7);
 
641
 
 
642
        var _R = OpenLayers.Protocol.Response;
 
643
        OpenLayers.Protocol.Response = function() {
 
644
            this.priv = {status: 200};
 
645
        };
 
646
 
 
647
        // test that read with no options uses protocol options - 5 tests
 
648
        var url = "foo";
 
649
        var headers = {};
 
650
        var params = {};
 
651
        var scope = {};
 
652
        var protocol = new OpenLayers.Protocol.HTTP({
 
653
            format: new OpenLayers.Format({read: function(){}, write: function(){}}),
 
654
            url: url,
 
655
            headers: headers,
 
656
            params: params,
 
657
            callback: function() {
 
658
                t.ok(true, "[read] Correct callback.");
 
659
                t.eq(this, scope, "[read] Correct scope.");
 
660
            },
 
661
            scope: scope
 
662
        });        
 
663
        var _issue = OpenLayers.Request.issue;
 
664
        OpenLayers.Request.issue = function(config) {
 
665
            t.eq(config.url, url, "[" + config.method + "] Correct url.");
 
666
            t.eq(config.headers, headers, "[" + config.method + "] Correct headers.");
 
667
            t.eq(config.params, params, "[" + config.method + "] Correct params.");
 
668
            config.callback.call(config.scope);
 
669
        };
 
670
        protocol.read();
 
671
        OpenLayers.Request.issue = _issue;
 
672
 
 
673
        // test that commit with no options uses protocol options - 2 tests
 
674
        _issue = OpenLayers.Request.issue;
 
675
        OpenLayers.Request.issue = function(config) {
 
676
            config.callback.call(config.scope);
 
677
        };
 
678
        var called = 0;
 
679
        protocol.options.callback = function() {
 
680
            called++;
 
681
            t.eq(this, scope, "[commit] Correct scope.");
 
682
        };
 
683
        protocol.commit([
 
684
            {state: OpenLayers.State.INSERT},
 
685
            {state: OpenLayers.State.INSERT},
 
686
            {state: OpenLayers.State.UPDATE},
 
687
            {state: OpenLayers.State.UPDATE},
 
688
            {state: OpenLayers.State.DELETE},
 
689
            {state: OpenLayers.State.DELETE}
 
690
        ]);
 
691
        t.eq(called, 1, "[commit] Callback called once.");
 
692
 
 
693
        // cleanup
 
694
        protocol.destroy();
 
695
        OpenLayers.Protocol.Response = _R;
 
696
    }
 
697
 
 
698
 
 
699
  </script>
 
700
</head>
 
701
<body>
 
702
</body>
 
703
</html>