The Tor Browser / file comparison

comparison: services/common/tests/unit/test_storageservice_client.js

services/common/tests/unit/test_storageservice_client.js

branch
TOR_BUG_9701
changeset 14
925c144e1f1f
equal deleted inserted replaced
-1:000000000000 0:26e9d6517f98
1 /* Any copyright is dedicated to the Public Domain.
2 * http://creativecommons.org/publicdomain/zero/1.0/ */
3
4 Cu.import("resource://services-common/storageservice.js");
5 Cu.import("resource://testing-common/services-common/storageserver.js");
6
7 function run_test() {
8 initTestLogging("Trace");
9
10 run_next_test();
11 }
12
13 function getRandomUser() {
14 return "" + (Math.floor(Math.random() * 100000) + 1);
15 }
16
17 function getEmptyServer(user=getRandomUser(), password="password") {
18 let users = {};
19 users[user] = password;
20
21 return storageServerForUsers(users, {
22 meta: {},
23 clients: {},
24 crypto: {},
25 });
26 }
27
28 function getClient(server, user=getRandomUser(), password="password") {
29 let identity = server.server.identity;
30 let url = identity.primaryScheme + "://" + identity.primaryHost + ":" +
31 identity.primaryPort + "/2.0/" + user;
32 let client = new StorageServiceClient(url);
33 client.addListener({
34 onDispatch: function onDispatch(request) {
35 let up = user + ":" + password;
36 request.request.setHeader("authorization", "Basic " + btoa(up));
37 }
38 });
39
40 return client;
41 }
42
43 function getServerAndClient(user=getRandomUser(), password="password") {
44 let server = getEmptyServer(user, password);
45 let client = getClient(server, user, password);
46
47 return [server, client, user, password];
48 }
49
50 add_test(function test_auth_failure_listener() {
51 _("Ensure the onAuthFailure listener is invoked.");
52
53 let server = getEmptyServer();
54 let client = getClient(server, "324", "INVALID");
55 client.addListener({
56 onAuthFailure: function onAuthFailure(client, request) {
57 _("onAuthFailure");
58 server.stop(run_next_test);
59 }
60 });
61
62 let request = client.getCollectionInfo();
63 request.dispatch();
64 });
65
66 add_test(function test_duplicate_listeners() {
67 _("Ensure that duplicate listeners aren't installed multiple times.");
68
69 let server = getEmptyServer();
70 let client = getClient(server, "1234567", "BAD_PASSWORD");
71
72 let invokeCount = 0;
73 let listener = {
74 onAuthFailure: function onAuthFailure() {
75 invokeCount++;
76 }
77 };
78
79 client.addListener(listener);
80 // No error expected.
81 client.addListener(listener);
82
83 let request = client.getCollectionInfo();
84 request.dispatch(function onComplete() {
85 do_check_eq(invokeCount, 1);
86
87 server.stop(run_next_test);
88 });
89 });
90
91 add_test(function test_handler_object() {
92 _("Ensure that installed handlers get their callbacks invoked.");
93
94 let [server, client] = getServerAndClient();
95
96 let onCompleteCount = 0;
97 let onDispatchCount = 0;
98
99 let handler = {
100 onComplete: function onComplete() {
101 onCompleteCount++;
102
103 do_check_eq(onDispatchCount, 1);
104 do_check_eq(onCompleteCount, 1);
105
106 server.stop(run_next_test);
107 },
108
109 onDispatch: function onDispatch() {
110 onDispatchCount++;
111 },
112 };
113 let request = client.getCollectionInfo();
114 request.handler = handler;
115 request.dispatch();
116 });
117
118 add_test(function test_info_collections() {
119 _("Ensure requests to /info/collections work as expected.");
120
121 let [server, client] = getServerAndClient();
122
123 let request = client.getCollectionInfo();
124 request.dispatch(function onComplete(error, req) {
125 do_check_null(error);
126 do_check_eq("object", typeof req.resultObj);
127 do_check_attribute_count(req.resultObj, 3);
128 do_check_true("meta" in req.resultObj);
129
130 server.stop(run_next_test);
131 });
132 });
133
134 add_test(function test_info_collections_conditional_not_modified() {
135 _("Ensure conditional getCollectionInfo requests work.");
136
137 let [server, client, username] = getServerAndClient();
138 let user = server.user(username);
139
140 let now = Date.now();
141
142 user.createCollection("testcoll", {
143 foo: new ServerBSO("foo", "payload", now)
144 });
145
146 let request = client.getCollectionInfo();
147 request.locallyModifiedVersion = now + 10;
148 request.dispatch(function onComplete(error, req) {
149 do_check_null(error);
150 do_check_true(req.notModified);
151
152 server.stop(run_next_test);
153 });
154 });
155
156 add_test(function test_info_collections_conditional_modified() {
157 _("Ensure conditional getCollectionInfo requests work.");
158
159 let [server, client, username] = getServerAndClient();
160 let user = server.user(username);
161
162 let now = Date.now();
163
164 user.createCollection("testcoll", {
165 foo: new ServerBSO("foo", "payload", now)
166 });
167
168 let request = client.getCollectionInfo();
169 request.locallyModifiedVersion = now - 10;
170 request.dispatch(function onComplete(error, req) {
171 do_check_null(error);
172 do_check_false(req.notModified);
173
174 server.stop(run_next_test);
175 });
176 });
177
178 add_test(function test_get_quota() {
179 _("Ensure quota requests work.");
180
181 let [server, client] = getServerAndClient();
182
183 let request = client.getQuota();
184 request.dispatch(function onComplete(error, req) {
185 do_check_null(error);
186
187 do_check_eq(req.resultObj.quota, 1048576);
188
189 server.stop(run_next_test);
190 });
191 });
192
193 add_test(function test_get_quota_conditional_not_modified() {
194 _("Ensure conditional getQuota requests work.");
195
196 let [server, client, username] = getServerAndClient();
197 let user = server.user(username);
198
199 let now = Date.now();
200
201 user.createCollection("testcoll", {
202 foo: new ServerBSO("foo", "payload", now)
203 });
204
205 let request = client.getQuota();
206 request.locallyModifiedVersion = now + 10;
207 request.dispatch(function onComplete(error, req) {
208 do_check_null(error);
209 do_check_true(req.notModified);
210
211 server.stop(run_next_test);
212 });
213 });
214
215 add_test(function test_get_quota_conditional_modified() {
216 _("Ensure conditional getQuota requests work.");
217
218 let [server, client, username] = getServerAndClient();
219 let user = server.user(username);
220
221 let now = Date.now();
222
223 user.createCollection("testcoll", {
224 foo: new ServerBSO("foo", "payload", now)
225 });
226
227 let request = client.getQuota();
228 request.locallyModifiedVersion = now - 10;
229 request.dispatch(function onComplete(error, req) {
230 do_check_null(error);
231 do_check_false(req.notModified);
232
233 server.stop(run_next_test);
234 });
235 });
236
237 add_test(function test_get_collection_usage() {
238 _("Ensure info/collection_usage requests work.");
239
240 let [server, client, username] = getServerAndClient();
241 let user = server.user(username);
242
243 user.createCollection("testcoll", {
244 abc123: new ServerBSO("abc123", "payload", Date.now())
245 });
246
247 let request = client.getCollectionUsage();
248 request.dispatch(function onComplete(error, req) {
249 do_check_null(error);
250
251 let usage = req.resultObj;
252 do_check_true("testcoll" in usage);
253 do_check_eq(usage.testcoll, "payload".length);
254
255 server.stop(run_next_test);
256 });
257 });
258
259 add_test(function test_get_usage_conditional_not_modified() {
260 _("Ensure conditional getCollectionUsage requests work.");
261
262 let [server, client, username] = getServerAndClient();
263 let user = server.user(username);
264
265 let now = Date.now();
266
267 user.createCollection("testcoll", {
268 foo: new ServerBSO("foo", "payload", now)
269 });
270
271 let request = client.getCollectionUsage();
272 request.locallyModifiedVersion = now + 10;
273 request.dispatch(function onComplete(error, req) {
274 do_check_null(error);
275 do_check_true(req.notModified);
276
277 server.stop(run_next_test);
278 });
279 });
280
281 add_test(function test_get_usage_conditional_modified() {
282 _("Ensure conditional getCollectionUsage requests work.");
283
284 let [server, client, username] = getServerAndClient();
285 let user = server.user(username);
286
287 let now = Date.now();
288
289 user.createCollection("testcoll", {
290 foo: new ServerBSO("foo", "payload", now)
291 });
292
293 let request = client.getCollectionUsage();
294 request.locallyModifiedVersion = now - 10;
295 request.dispatch(function onComplete(error, req) {
296 do_check_null(error);
297 do_check_false(req.notModified);
298
299 server.stop(run_next_test);
300 });
301 });
302
303 add_test(function test_get_collection_counts() {
304 _("Ensure info/collection_counts requests work.");
305
306 let [server, client, username] = getServerAndClient();
307 let user = server.user(username);
308
309 user.createCollection("testcoll", {
310 foo: new ServerBSO("foo", "payload0", Date.now()),
311 bar: new ServerBSO("bar", "payload1", Date.now())
312 });
313
314 let request = client.getCollectionCounts();
315 request.dispatch(function onComplete(error, req) {
316 do_check_null(error);
317
318 let counts = req.resultObj;
319 do_check_true("testcoll" in counts);
320 do_check_eq(counts.testcoll, 2);
321
322 server.stop(run_next_test);
323 });
324 });
325
326 add_test(function test_get_counts_conditional_not_modified() {
327 _("Ensure conditional getCollectionCounts requests work.");
328
329 let [server, client, username] = getServerAndClient();
330 let user = server.user(username);
331
332 let now = Date.now();
333
334 user.createCollection("testcoll", {
335 foo: new ServerBSO("foo", "payload", now)
336 });
337
338 let request = client.getCollectionCounts();
339 request.locallyModifiedVersion = now + 10;
340 request.dispatch(function onComplete(error, req) {
341 do_check_null(error);
342 do_check_true(req.notModified);
343
344 server.stop(run_next_test);
345 });
346 });
347
348 add_test(function test_get_counts_conditional_modified() {
349 _("Ensure conditional getCollectionCounts requests work.");
350
351 let [server, client, username] = getServerAndClient();
352 let user = server.user(username);
353
354 let now = Date.now();
355
356 user.createCollection("testcoll", {
357 foo: new ServerBSO("foo", "payload", now)
358 });
359
360 let request = client.getCollectionCounts();
361 request.locallyModifiedVersion = now - 10;
362 request.dispatch(function onComplete(error, req) {
363 do_check_null(error);
364 do_check_false(req.notModified);
365
366 server.stop(run_next_test);
367 });
368 });
369
370 add_test(function test_get_collection_simple() {
371 _("Ensure basic collection retrieval works.");
372
373 let [server, client, username] = getServerAndClient();
374 let user = server.user(username);
375
376 user.createCollection("testcoll", {
377 foo: new ServerBSO("foo", "payload0", Date.now()),
378 bar: new ServerBSO("bar", "payload1", Date.now())
379 });
380
381 let request = client.getCollection("testcoll");
382 let bsos = [];
383 request.handler = {
384 onBSORecord: function onBSORecord(request, bso) {
385 bsos.push(bso);
386 },
387
388 onComplete: function onComplete(error, request) {
389 do_check_null(error);
390
391 do_check_eq(bsos.length, 2);
392 do_check_eq(bsos[0], "foo");
393 do_check_eq(bsos[1], "bar");
394
395 server.stop(run_next_test);
396 }
397 };
398 request.dispatch();
399 });
400
401 add_test(function test_get_collection_conditional_not_modified() {
402 _("Ensure conditional requests with no new data to getCollection work.");
403
404 let [server, client, username] = getServerAndClient();
405 let user = server.user(username);
406
407 let now = Date.now();
408
409 user.createCollection("testcoll", {
410 foo: new ServerBSO("foo", "payload0", now)
411 });
412
413 let request = client.getCollection("testcoll");
414 request.locallyModifiedVersion = now + 1;
415
416 request.dispatch(function onComplete(error, req) {
417 do_check_null(error);
418
419 do_check_true(req.notModified);
420
421 server.stop(run_next_test);
422 });
423 });
424
425 add_test(function test_get_collection_conditional_modified() {
426 _("Ensure conditional requests with new data to getCollection work.");
427
428 let [server, client, username] = getServerAndClient();
429 let user = server.user(username);
430
431 let now = Date.now();
432
433 user.createCollection("testcoll", {
434 foo: new ServerBSO("foo", "payload0", now)
435 });
436
437 let request = client.getCollection("testcoll");
438 request.locallyModifiedVersion = now - 1;
439
440 let bsoCount = 0;
441 request.handler = {
442 onBSORecord: function onBSORecord() {
443 bsoCount++;
444 },
445
446 onComplete: function onComplete(error, req) {
447 do_check_null(error);
448
449 do_check_false(req.notModified);
450 do_check_eq(bsoCount, 1);
451
452 server.stop(run_next_test);
453 }
454 };
455 request.dispatch();
456 });
457
458 // This is effectively a sanity test for query string generation.
459 add_test(function test_get_collection_newer() {
460 _("Ensure query string for newer and full work together.");
461
462 let [server, client, username] = getServerAndClient();
463
464 let date0 = Date.now();
465 let date1 = date0 + 500;
466
467 let user = server.user(username);
468 user.createCollection("testcoll", {
469 foo: new ServerBSO("foo", "payload0", date0),
470 bar: new ServerBSO("bar", "payload1", date1)
471 });
472
473 let request = client.getCollection("testcoll");
474 request.full = true;
475 request.newer = date0;
476
477 let bsos = [];
478 request.handler = {
479 onBSORecord: function onBSORecord(request, bso) {
480 bsos.push(bso);
481 },
482
483 onComplete: function onComplete(error, req) {
484 do_check_null(error);
485
486 do_check_eq(bsos.length, 1);
487 let bso = bsos[0];
488
489 do_check_eq(bso.id, "bar");
490 do_check_eq(bso.payload, "payload1");
491
492 server.stop(run_next_test);
493 }
494 };
495 request.dispatch();
496 });
497
498 add_test(function test_get_bso() {
499 _("Ensure that simple BSO fetches work.");
500
501 let [server, client, username] = getServerAndClient();
502
503 server.createCollection(username, "testcoll", {
504 abc123: new ServerBSO("abc123", "payload", Date.now())
505 });
506
507 let request = client.getBSO("testcoll", "abc123");
508 request.dispatch(function(error, req) {
509 do_check_null(error);
510 do_check_true(req.resultObj instanceof BasicStorageObject);
511
512 let bso = req.resultObj;
513 do_check_eq(bso.id, "abc123");
514 do_check_eq(bso.payload, "payload");
515
516 server.stop(run_next_test);
517 });
518 });
519
520 add_test(function test_bso_conditional() {
521 _("Ensure conditional requests for an individual BSO work.");
522
523 let [server, client, username] = getServerAndClient();
524
525 let user = server.user(username);
526 let now = Date.now();
527 user.createCollection("testcoll", {
528 foo: new ServerBSO("foo", "payload", now)
529 });
530
531 let request = client.getBSO("testcoll", "foo");
532 request.locallyModifiedVersion = now;
533
534 request.dispatch(function onComplete(error, req) {
535 do_check_null(error);
536 do_check_true(req.notModified);
537
538 server.stop(run_next_test);
539 });
540 });
541
542 add_test(function test_set_bso() {
543 _("Ensure simple BSO PUT works.");
544
545 let [server, client] = getServerAndClient();
546
547 let id = "mnas08h3f3r2351";
548
549 let bso = new BasicStorageObject(id, "testcoll");
550 bso.payload = "my test payload";
551
552 let request = client.setBSO(bso);
553 request.dispatch(function(error, req) {
554 do_check_eq(error, null);
555 do_check_eq(req.resultObj, null);
556
557 server.stop(run_next_test);
558 });
559 });
560
561
562 add_test(function test_set_bso_conditional() {
563 _("Ensure conditional setting a BSO is properly rejected.");
564
565 let [server, client, username] = getServerAndClient();
566 let user = server.user(username);
567
568 let now = Date.now();
569 user.createCollection("testcoll", {
570 foo: new ServerBSO("foo", "payload0", now + 1000)
571 });
572
573 // Should get an mtime newer than server's.
574 let bso = new BasicStorageObject("foo", "testcoll");
575 bso.payload = "payload1";
576
577 let request = client.setBSO(bso);
578 request.locallyModifiedVersion = now;
579 request.dispatch(function onComplete(error, req) {
580 do_check_true(error instanceof StorageServiceRequestError);
581 do_check_true(error.serverModified);
582
583 server.stop(run_next_test);
584 });
585 });
586
587 add_test(function test_set_bso_argument_errors() {
588 _("Ensure BSO set detects invalid arguments.");
589
590 let server = getEmptyServer();
591 let bso = new BasicStorageObject();
592 let client = getClient(server);
593
594 let threw = false;
595 try {
596 client.setBSO(bso);
597 } catch (ex) {
598 threw = true;
599 do_check_eq(ex.name, "Error");
600 do_check_neq(ex.message.indexOf("does not have collection defined"), -1);
601 } finally {
602 do_check_true(threw);
603 threw = false;
604 }
605
606 bso = new BasicStorageObject("id");
607 try {
608 client.setBSO(bso);
609 } catch (ex) {
610 threw = true;
611 do_check_eq(ex.name, "Error");
612 do_check_neq(ex.message.indexOf("does not have collection defined"), -1);
613 } finally {
614 do_check_true(threw);
615 threw = false;
616 }
617
618 bso = new BasicStorageObject(null, "coll");
619 try {
620 client.setBSO(bso);
621 } catch (ex) {
622 threw = true;
623 do_check_eq(ex.name, "Error");
624 do_check_neq(ex.message.indexOf("does not have ID defined"), -1);
625 } finally {
626 do_check_true(threw);
627 threw = false;
628 }
629
630 server.stop(run_next_test);
631 });
632
633 add_test(function test_set_bsos_simple() {
634 _("Ensure setBSOs with basic options works.");
635
636 let [server, client, username] = getServerAndClient();
637 let user = server.user(username);
638
639 let bso0 = new BasicStorageObject("foo");
640 bso0.payload = "payload0";
641
642 let bso1 = new BasicStorageObject("bar");
643 bso1.payload = "payload1";
644
645 let request = client.setBSOs("testcollection");
646 request.addBSO(bso0);
647 request.addBSO(bso1);
648
649 request.dispatch(function onComplete(error, req) {
650 do_check_null(error);
651
652 let successful = req.successfulIDs;
653 do_check_eq(successful.length, 2);
654 do_check_eq(successful.indexOf(bso0.id), 0);
655 do_check_true(successful.indexOf(bso1.id), 1);
656
657 server.stop(run_next_test);
658 });
659 });
660
661 add_test(function test_set_bsos_invalid_bso() {
662 _("Ensure that adding an invalid BSO throws.");
663
664 let server = getEmptyServer();
665 let client = getClient(server);
666 let request = client.setBSOs("testcoll");
667
668 let threw = false;
669
670 // Empty argument is invalid.
671 try {
672 request.addBSO(null);
673 } catch (ex) {
674 threw = true;
675 } finally {
676 do_check_true(threw);
677 threw = false;
678 }
679
680 try {
681 let bso = new BasicStorageObject();
682 request.addBSO(bso);
683 } catch (ex) {
684 threw = true;
685 } finally {
686 do_check_true(threw);
687 threw = false;
688 }
689
690 server.stop(run_next_test);
691 });
692
693 add_test(function test_set_bsos_newline() {
694 _("Ensure that newlines in BSO payloads are formatted properly.");
695
696 let [server, client, username] = getServerAndClient();
697 let user = server.user(username);
698
699 let request = client.setBSOs("testcoll");
700
701 let bso0 = new BasicStorageObject("bso0");
702 bso0.payload = "hello\nworld";
703 request.addBSO(bso0);
704
705 let bso1 = new BasicStorageObject("bso1");
706 bso1.payload = "foobar";
707 request.addBSO(bso1);
708
709 request.dispatch(function onComplete(error, request) {
710 do_check_null(error);
711 do_check_eq(request.successfulIDs.length, 2);
712
713 let coll = user.collection("testcoll");
714 do_check_eq(coll.bso("bso0").payload, bso0.payload);
715 do_check_eq(coll.bso("bso1").payload, bso1.payload);
716
717 server.stop(run_next_test);
718 });
719 });
720
721 add_test(function test_delete_bso_simple() {
722 _("Ensure deletion of individual BSOs works.");
723
724 let [server, client, username] = getServerAndClient();
725
726 let user = server.user(username);
727 let coll = user.createCollection("testcoll", {
728 foo: new ServerBSO("foo", "payload0", Date.now()),
729 bar: new ServerBSO("bar", "payload1", Date.now())
730 });
731
732 let request = client.deleteBSO("testcoll", "foo");
733 request.dispatch(function onComplete(error, req) {
734 do_check_null(error);
735 do_check_eq(req.statusCode, 204);
736
737 do_check_eq(coll.count(), 1);
738
739 server.stop(run_next_test);
740 });
741 });
742
743 add_test(function test_delete_bso_conditional_failed() {
744 _("Ensure deletion of an individual BSO with older modification fails.");
745
746 let [server, client, username] = getServerAndClient();
747 let user = server.user(username);
748
749 let now = Date.now();
750 user.createCollection("testcoll", {
751 foo: new ServerBSO("foo", "payload0", now)
752 });
753
754 let request = client.deleteBSO("testcoll", "foo");
755 request.locallyModifiedVersion = now - 10;
756
757 request.dispatch(function onComplete(error, req) {
758 do_check_true(error instanceof StorageServiceRequestError);
759 do_check_true(error.serverModified);
760
761 server.stop(run_next_test);
762 });
763 });
764
765 add_test(function test_delete_bso_conditional_success() {
766 _("Ensure deletion of an individual BSO with newer modification works.");
767
768 let [server, client, username] = getServerAndClient();
769 let user = server.user(username);
770
771 let now = Date.now();
772 user.createCollection("testcoll", {
773 foo: new ServerBSO("foo", "payload0", now)
774 });
775
776 let request = client.deleteBSO("testcoll", "foo");
777 request.locallyModifiedVersion = now;
778
779 request.dispatch(function onComplete(error, req) {
780 do_check_null(error);
781 do_check_eq(req.statusCode, 204);
782
783 server.stop(run_next_test);
784 });
785 });
786
787 add_test(function test_delete_bsos_simple() {
788 _("Ensure deletion of multiple BSOs works.");
789
790 let [server, client, username] = getServerAndClient();
791 let user = server.user(username);
792
793 let coll = user.createCollection("testcoll", {
794 foo: new ServerBSO("foo", "payload0", Date.now()),
795 bar: new ServerBSO("bar", "payload1", Date.now()),
796 baz: new ServerBSO("baz", "payload2", Date.now())
797 });
798
799 let request = client.deleteBSOs("testcoll", ["foo", "baz"]);
800 request.dispatch(function onComplete(error, req) {
801 do_check_null(error);
802 do_check_eq(req.statusCode, 204);
803
804 do_check_eq(coll.count(), 1);
805
806 server.stop(run_next_test);
807 });
808 });
809
810 add_test(function test_delete_bsos_conditional_failed() {
811 _("Ensure deletion of BSOs with server modifications fails.");
812
813 let [server, client, username] = getServerAndClient();
814 let user = server.user(username);
815
816 let now = Date.now();
817 let coll = user.createCollection("testcoll", {
818 foo: new ServerBSO("foo", "payload0", now)
819 });
820
821 let request = client.deleteBSOs("testcoll", ["foo"]);
822 request.locallyModifiedVersion = coll.timestamp - 1;
823
824 request.dispatch(function onComplete(error, req) {
825 do_check_true(error instanceof StorageServiceRequestError);
826 do_check_true(error.serverModified);
827
828 server.stop(run_next_test);
829 });
830 });
831
832 add_test(function test_delete_bsos_conditional_success() {
833 _("Ensure conditional deletion of BSOs without server modifications works.");
834
835 let [server, client, username] = getServerAndClient();
836 let user = server.user(username);
837
838 let now = Date.now();
839 let coll = user.createCollection("testcoll", {
840 foo: new ServerBSO("foo", "payload0", now),
841 bar: new ServerBSO("bar", "payload1", now - 10)
842 });
843
844 let request = client.deleteBSOs("testcoll", ["bar"]);
845 request.locallyModifiedVersion = coll.timestamp;
846
847 request.dispatch(function onComplete(error, req) {
848 do_check_null(error);
849
850 do_check_eq(req.statusCode, 204);
851
852 server.stop(run_next_test);
853 });
854 });
855
856 add_test(function test_delete_collection() {
857 _("Ensure deleteCollection() works.");
858
859 let [server, client, username] = getServerAndClient();
860 let user = server.user(username);
861
862 user.createCollection("testcoll", {
863 foo: new ServerBSO("foo", "payload0", Date.now())
864 });
865
866 let request = client.deleteCollection("testcoll");
867 request.dispatch(function onComplete(error, req) {
868 do_check_null(error);
869
870 do_check_eq(user.collection("testcoll", undefined));
871
872 server.stop(run_next_test);
873 });
874 });
875
876 add_test(function test_delete_collection_conditional_failed() {
877 _("Ensure conditional deletes with server modifications fail.");
878
879 let [server, client, username] = getServerAndClient();
880 let user = server.user(username);
881
882 let now = Date.now();
883
884 let coll = user.createCollection("testcoll", {
885 foo: new ServerBSO("foo", "payload0", now)
886 });
887
888 let request = client.deleteCollection("testcoll");
889 request.locallyModifiedVersion = coll.timestamp - 1;
890
891 request.dispatch(function onComplete(error, req) {
892 do_check_true(error instanceof StorageServiceRequestError);
893 do_check_true(error.serverModified);
894
895 server.stop(run_next_test);
896 });
897 });
898
899 add_test(function test_delete_collection_conditional_success() {
900 _("Ensure conditional delete of collection works when it's supposed to.");
901
902 let [server, client, username] = getServerAndClient();
903 let user = server.user(username);
904
905 let now = Date.now();
906
907 let coll = user.createCollection("testcoll", {
908 foo: new ServerBSO("foo", "payload0", now)
909 });
910
911 let request = client.deleteCollection("testcoll");
912 request.locallyModifiedVersion = coll.timestamp;
913
914 request.dispatch(function onComplete(error, req) {
915 do_check_null(error);
916
917 do_check_eq(user.collection("testcoll"), undefined);
918
919 server.stop(run_next_test);
920 });
921 });
922
923 add_test(function test_delete_collections() {
924 _("Ensure deleteCollections() works.");
925
926 let [server, client, username] = getServerAndClient();
927 let user = server.user(username);
928
929 user.createCollection("testColl", {
930 foo: new ServerBSO("foo", "payload0", Date.now())
931 });
932
933 let request = client.deleteCollections();
934 request.dispatch(function onComplete(error, req) {
935 do_check_null(error);
936
937 do_check_eq(user.collection("testcoll"), undefined);
938
939 server.stop(run_next_test);
940 });
941 });
942
943 add_test(function test_network_error_captured() {
944 _("Ensure network errors are captured.");
945
946 // Network errors should result in .networkError being set on request.
947 let client = new StorageServiceClient("http://rnewman-is-splendid.badtld/");
948
949 let request = client.getCollectionInfo();
950 request.dispatch(function(error, req) {
951 do_check_neq(error, null);
952 do_check_neq(error.network, null);
953
954 run_next_test();
955 });
956 });
957
958 add_test(function test_network_error_listener() {
959 _("Ensure the onNetworkError listener is invoked on network errors.");
960
961 let listenerCalled = false;
962
963 let client = new StorageServiceClient("http://philikon-is-too.badtld/");
964 client.addListener({
965 onNetworkError: function(client, request) {
966 listenerCalled = true;
967 }
968 });
969 let request = client.getCollectionInfo();
970 request.dispatch(function() {
971 do_check_true(listenerCalled);
972 run_next_test();
973 });
974 });
975
976 add_test(function test_batching_set_too_large() {
977 _("Ensure we throw when attempting to add a BSO that is too large to fit.");
978
979 let [server, client, username] = getServerAndClient();
980
981 let request = client.setBSOsBatching("testcoll");
982 let payload = "";
983
984 // The actual length of the payload is a little less. But, this ensures we
985 // exceed it.
986 for (let i = 0; i < client.REQUEST_SIZE_LIMIT; i++) {
987 payload += i;
988 }
989
990 let bso = new BasicStorageObject("bso");
991 bso.payload = payload;
992 do_check_throws(function add() { request.addBSO(bso); });
993
994 server.stop(run_next_test);
995 });
996
997 add_test(function test_batching_set_basic() {
998 _("Ensure batching set works with single requests.");
999
1000 let [server, client, username] = getServerAndClient();
1001
1002 let request = client.setBSOsBatching("testcoll");
1003 for (let i = 0; i < 10; i++) {
1004 let bso = new BasicStorageObject("bso" + i);
1005 bso.payload = "payload" + i;
1006 request.addBSO(bso);
1007 }
1008
1009 request.finish(function onFinish(request) {
1010 do_check_eq(request.successfulIDs.length, 10);
1011
1012 let collection = server.user(username).collection("testcoll");
1013 do_check_eq(collection.timestamp, request.serverModifiedVersion);
1014
1015 server.stop(run_next_test);
1016 });
1017 });
1018
1019 add_test(function test_batching_set_batch_count() {
1020 _("Ensure multiple outgoing request batching works when count is exceeded.");
1021
1022 let [server, client, username] = getServerAndClient();
1023 let requestCount = 0;
1024 server.callback.onRequest = function onRequest() {
1025 requestCount++;
1026 }
1027
1028 let request = client.setBSOsBatching("testcoll");
1029 for (let i = 1; i <= 300; i++) {
1030 let bso = new BasicStorageObject("bso" + i);
1031 bso.payload = "XXXXXXX";
1032 request.addBSO(bso);
1033 }
1034
1035 request.finish(function onFinish(request) {
1036 do_check_eq(request.successfulIDs.length, 300);
1037 do_check_eq(requestCount, 3);
1038
1039 let collection = server.user(username).collection("testcoll");
1040 do_check_eq(collection.timestamp, request.serverModifiedVersion);
1041
1042 server.stop(run_next_test);
1043 });
1044 });
1045
1046 add_test(function test_batching_set_batch_size() {
1047 _("Ensure outgoing requests batch when size is exceeded.");
1048
1049 let [server, client, username] = getServerAndClient();
1050 let requestCount = 0;
1051 server.callback.onRequest = function onRequest() {
1052 requestCount++;
1053 };
1054
1055 let limit = client.REQUEST_SIZE_LIMIT;
1056
1057 let request = client.setBSOsBatching("testcoll");
1058
1059 // JavaScript: Y U NO EASY REPETITION FUNCTIONALITY?
1060 let data = [];
1061 for (let i = (limit / 2) - 100; i; i -= 1) {
1062 data.push("X");
1063 }
1064
1065 let payload = data.join("");
1066
1067 for (let i = 0; i < 4; i++) {
1068 let bso = new BasicStorageObject("bso" + i);
1069 bso.payload = payload;
1070 request.addBSO(bso);
1071 }
1072
1073 request.finish(function onFinish(request) {
1074 do_check_eq(request.successfulIDs.length, 4);
1075 do_check_eq(requestCount, 2);
1076
1077 let collection = server.user(username).collection("testcoll");
1078 do_check_eq(collection.timestamp, request.serverModifiedVersion);
1079
1080 server.stop(run_next_test);
1081 });
1082 });
1083
1084 add_test(function test_batching_set_flush() {
1085 _("Ensure flushing batch sets works.");
1086
1087 let [server, client, username] = getServerAndClient();
1088
1089 let requestCount = 0;
1090 server.callback.onRequest = function onRequest() {
1091 requestCount++;
1092 }
1093
1094 let request = client.setBSOsBatching("testcoll");
1095 for (let i = 1; i < 101; i++) {
1096 let bso = new BasicStorageObject("bso" + i);
1097 bso.payload = "foo";
1098 request.addBSO(bso);
1099
1100 if (i % 10 == 0) {
1101 request.flush();
1102 }
1103 }
1104
1105 request.finish(function onFinish(request) {
1106 do_check_eq(request.successfulIDs.length, 100);
1107 do_check_eq(requestCount, 10);
1108
1109 let collection = server.user(username).collection("testcoll");
1110 do_check_eq(collection.timestamp, request.serverModifiedVersion);
1111
1112 server.stop(run_next_test);
1113 });
1114 });
1115
1116 add_test(function test_batching_set_conditional_success() {
1117 _("Ensure conditional requests for batched sets work properly.");
1118
1119 let [server, client, username] = getServerAndClient();
1120
1121 let collection = server.user(username).createCollection("testcoll");
1122
1123 let lastServerVersion = Date.now();
1124 collection.insertBSO(new ServerBSO("foo", "bar", lastServerVersion));
1125 collection.timestamp = lastServerVersion;
1126 do_check_eq(collection.timestamp, lastServerVersion);
1127
1128 let requestCount = 0;
1129 server.callback.onRequest = function onRequest() {
1130 requestCount++;
1131 }
1132
1133 let request = client.setBSOsBatching("testcoll");
1134 request.locallyModifiedVersion = collection.timestamp;
1135
1136 for (let i = 1; i < 251; i++) {
1137 let bso = new BasicStorageObject("bso" + i);
1138 bso.payload = "foo" + i;
1139 request.addBSO(bso);
1140 }
1141
1142 request.finish(function onFinish(request) {
1143 do_check_eq(requestCount, 3);
1144
1145 do_check_eq(collection.timestamp, request.serverModifiedVersion);
1146 do_check_eq(collection.timestamp, request.locallyModifiedVersion);
1147
1148 server.stop(run_next_test);
1149 });
1150 });
1151
1152 add_test(function test_batching_set_initial_failure() {
1153 _("Ensure that an initial request failure setting BSOs is handled properly.");
1154
1155 let [server, client, username] = getServerAndClient();
1156
1157 let collection = server.user(username).createCollection("testcoll");
1158 collection.timestamp = Date.now();
1159
1160 let requestCount = 0;
1161 server.callback.onRequest = function onRequest() {
1162 requestCount++;
1163 }
1164
1165 let request = client.setBSOsBatching("testcoll");
1166 request.locallyModifiedVersion = collection.timestamp - 1;
1167
1168 for (let i = 1; i < 250; i++) {
1169 let bso = new BasicStorageObject("bso" + i);
1170 bso.payload = "foo" + i;
1171 request.addBSO(bso);
1172 }
1173
1174 request.finish(function onFinish(request) {
1175 do_check_eq(requestCount, 1);
1176
1177 do_check_eq(request.successfulIDs.length, 0);
1178 do_check_eq(Object.keys(request.failures).length, 0);
1179
1180 server.stop(run_next_test);
1181 });
1182 });
1183
1184 add_test(function test_batching_set_subsequent_failure() {
1185 _("Ensure a non-initial failure during batching set is handled properly.");
1186
1187 let [server, client, username] = getServerAndClient();
1188 let collection = server.user(username).createCollection("testcoll");
1189 collection.timestamp = Date.now();
1190
1191 let requestCount = 0;
1192 server.callback.onRequest = function onRequest() {
1193 requestCount++;
1194
1195 if (requestCount == 1) {
1196 return;
1197 }
1198
1199 collection.timestamp++;
1200 }
1201
1202 let request = client.setBSOsBatching("testcoll");
1203 request.locallyModifiedVersion = collection.timestamp;
1204
1205 for (let i = 0; i < 250; i++) {
1206 let bso = new BasicStorageObject("bso" + i);
1207 bso.payload = "foo" + i;
1208 request.addBSO(bso);
1209 }
1210
1211 request.finish(function onFinish(request) {
1212 do_check_eq(requestCount, 2);
1213 do_check_eq(request.successfulIDs.length, 100);
1214 do_check_eq(Object.keys(request.failures).length, 0);
1215
1216 server.stop(run_next_test);
1217 });
1218 });
1219
1220 function getBatchedDeleteData(collection="testcoll") {
1221 let [server, client, username] = getServerAndClient();
1222
1223 let serverBSOs = {};
1224 for (let i = 1000; i; i -= 1) {
1225 serverBSOs["bso" + i] = new ServerBSO("bso" + i, "payload" + i);
1226 }
1227
1228 let user = server.user(username);
1229 user.createCollection(collection, serverBSOs);
1230
1231 return [server, client, username, collection];
1232 }
1233
1234 add_test(function test_batched_delete_single() {
1235 _("Ensure batched delete with single request works.");
1236
1237 let [server, client, username, collection] = getBatchedDeleteData();
1238
1239 let requestCount = 0;
1240 server.callback.onRequest = function onRequest() {
1241 requestCount += 1;
1242 }
1243
1244 let request = client.deleteBSOsBatching(collection);
1245 for (let i = 1; i < 51; i += 1) {
1246 request.addID("bso" + i);
1247 }
1248
1249 request.finish(function onFinish(request) {
1250 do_check_eq(requestCount, 1);
1251 do_check_eq(request.errors.length, 0);
1252
1253 let coll = server.user(username).collection(collection);
1254 do_check_eq(coll.count(), 950);
1255
1256 do_check_eq(request.serverModifiedVersion, coll.timestamp);
1257
1258 server.stop(run_next_test);
1259 });
1260 });
1261
1262 add_test(function test_batched_delete_multiple() {
1263 _("Ensure batched delete splits requests properly.");
1264
1265 let [server, client, username, collection] = getBatchedDeleteData();
1266
1267 let requestCount = 0;
1268 server.callback.onRequest = function onRequest() {
1269 requestCount += 1;
1270 }
1271
1272 let request = client.deleteBSOsBatching(collection);
1273 for (let i = 1; i < 251; i += 1) {
1274 request.addID("bso" + i);
1275 }
1276
1277 request.finish(function onFinish(request) {
1278 do_check_eq(requestCount, 3);
1279 do_check_eq(request.errors.length, 0);
1280
1281 let coll = server.user(username).collection(collection);
1282 do_check_eq(coll.count(), 750);
1283
1284 do_check_eq(request.serverModifiedVersion, coll.timestamp);
1285
1286 server.stop(run_next_test);
1287 });
1288 });
1289
1290 add_test(function test_batched_delete_conditional_success() {
1291 _("Ensure conditional batched delete all work.");
1292
1293 let [server, client, username, collection] = getBatchedDeleteData();
1294
1295 let requestCount = 0;
1296 server.callback.onRequest = function onRequest() {
1297 requestCount++;
1298 }
1299
1300 let serverCollection = server.user(username).collection(collection);
1301 let initialTimestamp = serverCollection.timestamp;
1302
1303 let request = client.deleteBSOsBatching(collection);
1304 request.locallyModifiedVersion = initialTimestamp;
1305
1306 for (let i = 1; i < 251; i += 1) {
1307 request.addID("bso" + 1);
1308 }
1309
1310 request.finish(function onFinish(request) {
1311 do_check_eq(requestCount, 3);
1312 do_check_eq(request.errors.length, 0);
1313
1314 do_check_true(request.locallyModifiedVersion > initialTimestamp);
1315
1316 server.stop(run_next_test);
1317 });
1318 });
1319
1320 add_test(function test_batched_delete_conditional_initial_failure() {
1321 _("Ensure conditional batched delete failure on initial request works.");
1322
1323 // The client needs to issue multiple requests but the first one was
1324 // rejected. The client should only issue that initial request.
1325 let [server, client, username, collection] = getBatchedDeleteData();
1326
1327 let requestCount = 0;
1328 server.callback.onRequest = function onRequest() {
1329 requestCount++;
1330 }
1331
1332 let serverCollection = server.user(username).collection(collection);
1333 let request = client.deleteBSOsBatching(collection);
1334 request.locallyModifiedVersion = serverCollection.timestamp - 1;
1335
1336 for (let i = 1; i < 251; i += 1) {
1337 request.addID("bso" + i);
1338 }
1339
1340 request.finish(function onFinish(request) {
1341 do_check_eq(requestCount, 1);
1342 do_check_eq(request.errors.length, 1);
1343
1344 server.stop(run_next_test);
1345 });
1346 });
1347
1348 add_test(function test_batched_delete_conditional_subsequent_failure() {
1349 _("Ensure conditional batched delete failure on non-initial request.");
1350
1351 let [server, client, username, collection] = getBatchedDeleteData();
1352
1353 let serverCollection = server.user(username).collection(collection);
1354
1355 let requestCount = 0;
1356 server.callback.onRequest = function onRequest() {
1357 requestCount++;
1358
1359 if (requestCount <= 1) {
1360 return;
1361 }
1362
1363 // Advance collection's timestamp on subsequent requests so request is
1364 // rejected.
1365 serverCollection.timestamp++;
1366 }
1367
1368 let request = client.deleteBSOsBatching(collection);
1369 request.locallyModifiedVersion = serverCollection.timestamp;
1370
1371 for (let i = 1; i < 251; i += 1) {
1372 request.addID("bso" + i);
1373 }
1374
1375 request.finish(function onFinish(request) {
1376 do_check_eq(requestCount, 2);
1377 do_check_eq(request.errors.length, 1);
1378
1379 server.stop(run_next_test);
1380 });
1381 });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial