The Tor Browser: services/common/tests/unit/test_storageservice

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* Any copyright is dedicated to the Public Domain.

     2  * http://creativecommons.org/publicdomain/zero/1.0/ */

     4 Cu.import("resource://services-common/storageservice.js");

     5 Cu.import("resource://testing-common/services-common/storageserver.js");

     7 function run_test() {

     8   initTestLogging("Trace");

    10   run_next_test();

    11 }

    13 function getRandomUser() {

    14   return "" + (Math.floor(Math.random() * 100000) + 1);

    15 }

    17 function getEmptyServer(user=getRandomUser(), password="password") {

    18   let users = {};

    19   users[user] = password;

    21   return storageServerForUsers(users, {

    22     meta:    {},

    23     clients: {},

    24     crypto:  {},

    25   });

    26 }

    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   });

    40   return client;

    41 }

    43 function getServerAndClient(user=getRandomUser(), password="password") {

    44   let server = getEmptyServer(user, password);

    45   let client = getClient(server, user, password);

    47   return [server, client, user, password];

    48 }

    50 add_test(function test_auth_failure_listener() {

    51   _("Ensure the onAuthFailure listener is invoked.");

    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   });

    62   let request = client.getCollectionInfo();

    63   request.dispatch();

    64 });

    66 add_test(function test_duplicate_listeners() {

    67   _("Ensure that duplicate listeners aren't installed multiple times.");

    69   let server = getEmptyServer();

    70   let client = getClient(server, "1234567", "BAD_PASSWORD");

    72   let invokeCount = 0;

    73   let listener = {

    74     onAuthFailure: function onAuthFailure() {

    75       invokeCount++;

    76     }

    77   };

    79   client.addListener(listener);

    80   // No error expected.

    81   client.addListener(listener);

    83   let request = client.getCollectionInfo();

    84   request.dispatch(function onComplete() {

    85     do_check_eq(invokeCount, 1);

    87     server.stop(run_next_test);

    88   });

    89 });

    91 add_test(function test_handler_object() {

    92   _("Ensure that installed handlers get their callbacks invoked.");

    94   let [server, client] = getServerAndClient();

    96   let onCompleteCount = 0;

    97   let onDispatchCount = 0;

    99   let handler = {

   100     onComplete: function onComplete() {

   101       onCompleteCount++;

   103       do_check_eq(onDispatchCount, 1);

   104       do_check_eq(onCompleteCount, 1);

   106       server.stop(run_next_test);

   107     },

   109     onDispatch: function onDispatch() {

   110       onDispatchCount++;

   111     },

   112   };

   113   let request = client.getCollectionInfo();

   114   request.handler = handler;

   115   request.dispatch();

   116 });

   118 add_test(function test_info_collections() {

   119   _("Ensure requests to /info/collections work as expected.");

   121   let [server, client] = getServerAndClient();

   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);

   130     server.stop(run_next_test);

   131   });

   132 });

   134 add_test(function test_info_collections_conditional_not_modified() {

   135   _("Ensure conditional getCollectionInfo requests work.");

   137   let [server, client, username] = getServerAndClient();

   138   let user = server.user(username);

   140   let now = Date.now();

   142   user.createCollection("testcoll", {

   143     foo: new ServerBSO("foo", "payload", now)

   144   });

   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);

   152     server.stop(run_next_test);

   153   });

   154 });

   156 add_test(function test_info_collections_conditional_modified() {

   157   _("Ensure conditional getCollectionInfo requests work.");

   159   let [server, client, username] = getServerAndClient();

   160   let user = server.user(username);

   162   let now = Date.now();

   164   user.createCollection("testcoll", {

   165     foo: new ServerBSO("foo", "payload", now)

   166   });

   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);

   174     server.stop(run_next_test);

   175   });

   176 });

   178 add_test(function test_get_quota() {

   179   _("Ensure quota requests work.");

   181   let [server, client] = getServerAndClient();

   183   let request = client.getQuota();

   184   request.dispatch(function onComplete(error, req) {

   185     do_check_null(error);

   187     do_check_eq(req.resultObj.quota, 1048576);

   189     server.stop(run_next_test);

   190   });

   191 });

   193 add_test(function test_get_quota_conditional_not_modified() {

   194   _("Ensure conditional getQuota requests work.");

   196   let [server, client, username] = getServerAndClient();

   197   let user = server.user(username);

   199   let now = Date.now();

   201   user.createCollection("testcoll", {

   202     foo: new ServerBSO("foo", "payload", now)

   203   });

   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);

   211     server.stop(run_next_test);

   212   });

   213 });

   215 add_test(function test_get_quota_conditional_modified() {

   216   _("Ensure conditional getQuota requests work.");

   218   let [server, client, username] = getServerAndClient();

   219   let user = server.user(username);

   221   let now = Date.now();

   223   user.createCollection("testcoll", {

   224     foo: new ServerBSO("foo", "payload", now)

   225   });

   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);

   233     server.stop(run_next_test);

   234   });

   235 });

   237 add_test(function test_get_collection_usage() {

   238   _("Ensure info/collection_usage requests work.");

   240   let [server, client, username] = getServerAndClient();

   241   let user = server.user(username);

   243   user.createCollection("testcoll", {

   244     abc123: new ServerBSO("abc123", "payload", Date.now())

   245   });

   247   let request = client.getCollectionUsage();

   248   request.dispatch(function onComplete(error, req) {

   249     do_check_null(error);

   251     let usage = req.resultObj;

   252     do_check_true("testcoll" in usage);

   253     do_check_eq(usage.testcoll, "payload".length);

   255     server.stop(run_next_test);

   256   });

   257 });

   259 add_test(function test_get_usage_conditional_not_modified() {

   260   _("Ensure conditional getCollectionUsage requests work.");

   262   let [server, client, username] = getServerAndClient();

   263   let user = server.user(username);

   265   let now = Date.now();

   267   user.createCollection("testcoll", {

   268     foo: new ServerBSO("foo", "payload", now)

   269   });

   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);

   277     server.stop(run_next_test);

   278   });

   279 });

   281 add_test(function test_get_usage_conditional_modified() {

   282   _("Ensure conditional getCollectionUsage requests work.");

   284   let [server, client, username] = getServerAndClient();

   285   let user = server.user(username);

   287   let now = Date.now();

   289   user.createCollection("testcoll", {

   290     foo: new ServerBSO("foo", "payload", now)

   291   });

   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);

   299     server.stop(run_next_test);

   300   });

   301 });

   303 add_test(function test_get_collection_counts() {

   304   _("Ensure info/collection_counts requests work.");

   306   let [server, client, username] = getServerAndClient();

   307   let user = server.user(username);

   309   user.createCollection("testcoll", {

   310     foo: new ServerBSO("foo", "payload0", Date.now()),

   311     bar: new ServerBSO("bar", "payload1", Date.now())

   312   });

   314   let request = client.getCollectionCounts();

   315   request.dispatch(function onComplete(error, req) {

   316     do_check_null(error);

   318     let counts = req.resultObj;

   319     do_check_true("testcoll" in counts);

   320     do_check_eq(counts.testcoll, 2);

   322     server.stop(run_next_test);

   323   });

   324 });

   326 add_test(function test_get_counts_conditional_not_modified() {

   327   _("Ensure conditional getCollectionCounts requests work.");

   329   let [server, client, username] = getServerAndClient();

   330   let user = server.user(username);

   332   let now = Date.now();

   334   user.createCollection("testcoll", {

   335     foo: new ServerBSO("foo", "payload", now)

   336   });

   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);

   344     server.stop(run_next_test);

   345   });

   346 });

   348 add_test(function test_get_counts_conditional_modified() {

   349   _("Ensure conditional getCollectionCounts requests work.");

   351   let [server, client, username] = getServerAndClient();

   352   let user = server.user(username);

   354   let now = Date.now();

   356   user.createCollection("testcoll", {

   357     foo: new ServerBSO("foo", "payload", now)

   358   });

   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);

   366     server.stop(run_next_test);

   367   });

   368 });

   370 add_test(function test_get_collection_simple() {

   371   _("Ensure basic collection retrieval works.");

   373   let [server, client, username] = getServerAndClient();

   374   let user = server.user(username);

   376   user.createCollection("testcoll", {

   377     foo: new ServerBSO("foo", "payload0", Date.now()),

   378     bar: new ServerBSO("bar", "payload1", Date.now())

   379   });

   381   let request = client.getCollection("testcoll");

   382   let bsos = [];

   383   request.handler = {

   384     onBSORecord: function onBSORecord(request, bso) {

   385       bsos.push(bso);

   386     },

   388     onComplete: function onComplete(error, request) {

   389       do_check_null(error);

   391       do_check_eq(bsos.length, 2);

   392       do_check_eq(bsos[0], "foo");

   393       do_check_eq(bsos[1], "bar");

   395       server.stop(run_next_test);

   396     }

   397   };

   398   request.dispatch();

   399 });

   401 add_test(function test_get_collection_conditional_not_modified() {

   402   _("Ensure conditional requests with no new data to getCollection work.");

   404   let [server, client, username] = getServerAndClient();

   405   let user = server.user(username);

   407   let now = Date.now();

   409   user.createCollection("testcoll", {

   410     foo: new ServerBSO("foo", "payload0", now)

   411   });

   413   let request = client.getCollection("testcoll");

   414   request.locallyModifiedVersion = now + 1;

   416   request.dispatch(function onComplete(error, req) {

   417     do_check_null(error);

   419     do_check_true(req.notModified);

   421     server.stop(run_next_test);

   422   });

   423 });

   425 add_test(function test_get_collection_conditional_modified() {

   426   _("Ensure conditional requests with new data to getCollection work.");

   428   let [server, client, username] = getServerAndClient();

   429   let user = server.user(username);

   431   let now = Date.now();

   433   user.createCollection("testcoll", {

   434     foo: new ServerBSO("foo", "payload0", now)

   435   });

   437   let request = client.getCollection("testcoll");

   438   request.locallyModifiedVersion = now - 1;

   440   let bsoCount = 0;

   441   request.handler = {

   442     onBSORecord: function onBSORecord() {

   443       bsoCount++;

   444     },

   446     onComplete: function onComplete(error, req) {

   447       do_check_null(error);

   449       do_check_false(req.notModified);

   450       do_check_eq(bsoCount, 1);

   452       server.stop(run_next_test);

   453     }

   454   };

   455   request.dispatch();

   456 });

   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.");

   462   let [server, client, username] = getServerAndClient();

   464   let date0 = Date.now();

   465   let date1 = date0 + 500;

   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   });

   473   let request = client.getCollection("testcoll");

   474   request.full = true;

   475   request.newer = date0;

   477   let bsos = [];

   478   request.handler = {

   479     onBSORecord: function onBSORecord(request, bso) {

   480       bsos.push(bso);

   481     },

   483     onComplete: function onComplete(error, req) {

   484       do_check_null(error);

   486       do_check_eq(bsos.length, 1);

   487       let bso = bsos[0];

   489       do_check_eq(bso.id, "bar");

   490       do_check_eq(bso.payload, "payload1");

   492       server.stop(run_next_test);

   493     }

   494   };

   495   request.dispatch();

   496 });

   498 add_test(function test_get_bso() {

   499   _("Ensure that simple BSO fetches work.");

   501   let [server, client, username] = getServerAndClient();

   503   server.createCollection(username, "testcoll", {

   504     abc123: new ServerBSO("abc123", "payload", Date.now())

   505   });

   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);

   512     let bso = req.resultObj;

   513     do_check_eq(bso.id, "abc123");

   514     do_check_eq(bso.payload, "payload");

   516     server.stop(run_next_test);

   517   });

   518 });

   520 add_test(function test_bso_conditional() {

   521   _("Ensure conditional requests for an individual BSO work.");

   523   let [server, client, username] = getServerAndClient();

   525   let user = server.user(username);

   526   let now = Date.now();

   527   user.createCollection("testcoll", {

   528     foo: new ServerBSO("foo", "payload", now)

   529   });

   531   let request = client.getBSO("testcoll", "foo");

   532   request.locallyModifiedVersion = now;

   534   request.dispatch(function onComplete(error, req) {

   535     do_check_null(error);

   536     do_check_true(req.notModified);

   538     server.stop(run_next_test);

   539   });

   540 });

   542 add_test(function test_set_bso() {

   543   _("Ensure simple BSO PUT works.");

   545   let [server, client] = getServerAndClient();

   547   let id = "mnas08h3f3r2351";

   549   let bso = new BasicStorageObject(id, "testcoll");

   550   bso.payload = "my test payload";

   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);

   557     server.stop(run_next_test);

   558   });

   559 });

   562 add_test(function test_set_bso_conditional() {

   563   _("Ensure conditional setting a BSO is properly rejected.");

   565   let [server, client, username] = getServerAndClient();

   566   let user = server.user(username);

   568   let now = Date.now();

   569   user.createCollection("testcoll", {

   570     foo: new ServerBSO("foo", "payload0", now + 1000)

   571   });

   573   // Should get an mtime newer than server's.

   574   let bso = new BasicStorageObject("foo", "testcoll");

   575   bso.payload = "payload1";

   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);

   583     server.stop(run_next_test);

   584   });

   585 });

   587 add_test(function test_set_bso_argument_errors() {

   588   _("Ensure BSO set detects invalid arguments.");

   590   let server = getEmptyServer();

   591   let bso = new BasicStorageObject();

   592   let client = getClient(server);

   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   }

   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   }

   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   }

   630   server.stop(run_next_test);

   631 });

   633 add_test(function test_set_bsos_simple() {

   634   _("Ensure setBSOs with basic options works.");

   636   let [server, client, username] = getServerAndClient();

   637   let user = server.user(username);

   639   let bso0 = new BasicStorageObject("foo");

   640   bso0.payload = "payload0";

   642   let bso1 = new BasicStorageObject("bar");

   643   bso1.payload = "payload1";

   645   let request = client.setBSOs("testcollection");

   646   request.addBSO(bso0);

   647   request.addBSO(bso1);

   649   request.dispatch(function onComplete(error, req) {

   650     do_check_null(error);

   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);

   657     server.stop(run_next_test);

   658   });

   659 });

   661 add_test(function test_set_bsos_invalid_bso() {

   662   _("Ensure that adding an invalid BSO throws.");

   664   let server = getEmptyServer();

   665   let client = getClient(server);

   666   let request = client.setBSOs("testcoll");

   668   let threw = false;

   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   }

   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   }

   690   server.stop(run_next_test);

   691 });

   693 add_test(function test_set_bsos_newline() {

   694   _("Ensure that newlines in BSO payloads are formatted properly.");

   696   let [server, client, username] = getServerAndClient();

   697   let user = server.user(username);

   699   let request = client.setBSOs("testcoll");

   701   let bso0 = new BasicStorageObject("bso0");

   702   bso0.payload = "hello\nworld";

   703   request.addBSO(bso0);

   705   let bso1 = new BasicStorageObject("bso1");

   706   bso1.payload = "foobar";

   707   request.addBSO(bso1);

   709   request.dispatch(function onComplete(error, request) {

   710     do_check_null(error);

   711     do_check_eq(request.successfulIDs.length, 2);

   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);

   717     server.stop(run_next_test);

   718   });

   719 });

   721 add_test(function test_delete_bso_simple() {

   722   _("Ensure deletion of individual BSOs works.");

   724   let [server, client, username] = getServerAndClient();

   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   });

   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);

   737     do_check_eq(coll.count(), 1);

   739     server.stop(run_next_test);

   740   });

   741 });

   743 add_test(function test_delete_bso_conditional_failed() {

   744   _("Ensure deletion of an individual BSO with older modification fails.");

   746   let [server, client, username] = getServerAndClient();

   747   let user = server.user(username);

   749   let now = Date.now();

   750   user.createCollection("testcoll", {

   751     foo: new ServerBSO("foo", "payload0", now)

   752   });

   754   let request = client.deleteBSO("testcoll", "foo");

   755   request.locallyModifiedVersion = now - 10;

   757   request.dispatch(function onComplete(error, req) {

   758     do_check_true(error instanceof StorageServiceRequestError);

   759     do_check_true(error.serverModified);

   761     server.stop(run_next_test);

   762   });

   763 });

   765 add_test(function test_delete_bso_conditional_success() {

   766   _("Ensure deletion of an individual BSO with newer modification works.");

   768   let [server, client, username] = getServerAndClient();

   769   let user = server.user(username);

   771   let now = Date.now();

   772   user.createCollection("testcoll", {

   773     foo: new ServerBSO("foo", "payload0", now)

   774   });

   776   let request = client.deleteBSO("testcoll", "foo");

   777   request.locallyModifiedVersion = now;

   779   request.dispatch(function onComplete(error, req) {

   780     do_check_null(error);

   781     do_check_eq(req.statusCode, 204);

   783     server.stop(run_next_test);

   784   });

   785 });

   787 add_test(function test_delete_bsos_simple() {

   788   _("Ensure deletion of multiple BSOs works.");

   790   let [server, client, username] = getServerAndClient();

   791   let user = server.user(username);

   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   });

   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);

   804     do_check_eq(coll.count(), 1);

   806     server.stop(run_next_test);

   807   });

   808 });

   810 add_test(function test_delete_bsos_conditional_failed() {

   811   _("Ensure deletion of BSOs with server modifications fails.");

   813   let [server, client, username] = getServerAndClient();

   814   let user = server.user(username);

   816   let now = Date.now();

   817   let coll = user.createCollection("testcoll", {

   818     foo: new ServerBSO("foo", "payload0", now)

   819   });

   821   let request = client.deleteBSOs("testcoll", ["foo"]);

   822   request.locallyModifiedVersion = coll.timestamp - 1;

   824   request.dispatch(function onComplete(error, req) {

   825     do_check_true(error instanceof StorageServiceRequestError);

   826     do_check_true(error.serverModified);

   828     server.stop(run_next_test);

   829   });

   830 });

   832 add_test(function test_delete_bsos_conditional_success() {

   833   _("Ensure conditional deletion of BSOs without server modifications works.");

   835   let [server, client, username] = getServerAndClient();

   836   let user = server.user(username);

   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   });

   844   let request = client.deleteBSOs("testcoll", ["bar"]);

   845   request.locallyModifiedVersion = coll.timestamp;

   847   request.dispatch(function onComplete(error, req) {

   848     do_check_null(error);

   850     do_check_eq(req.statusCode, 204);

   852     server.stop(run_next_test);

   853   });

   854 });

   856 add_test(function test_delete_collection() {

   857   _("Ensure deleteCollection() works.");

   859   let [server, client, username] = getServerAndClient();

   860   let user = server.user(username);

   862   user.createCollection("testcoll", {

   863     foo: new ServerBSO("foo", "payload0", Date.now())

   864   });

   866   let request = client.deleteCollection("testcoll");

   867   request.dispatch(function onComplete(error, req) {

   868     do_check_null(error);

   870     do_check_eq(user.collection("testcoll", undefined));

   872     server.stop(run_next_test);

   873   });

   874 });

   876 add_test(function test_delete_collection_conditional_failed() {

   877   _("Ensure conditional deletes with server modifications fail.");

   879   let [server, client, username] = getServerAndClient();

   880   let user = server.user(username);

   882   let now = Date.now();

   884   let coll = user.createCollection("testcoll", {

   885     foo: new ServerBSO("foo", "payload0", now)

   886   });

   888   let request = client.deleteCollection("testcoll");

   889   request.locallyModifiedVersion = coll.timestamp - 1;

   891   request.dispatch(function onComplete(error, req) {

   892     do_check_true(error instanceof StorageServiceRequestError);

   893     do_check_true(error.serverModified);

   895     server.stop(run_next_test);

   896   });

   897 });

   899 add_test(function test_delete_collection_conditional_success() {

   900   _("Ensure conditional delete of collection works when it's supposed to.");

   902   let [server, client, username] = getServerAndClient();

   903   let user = server.user(username);

   905   let now = Date.now();

   907   let coll = user.createCollection("testcoll", {

   908     foo: new ServerBSO("foo", "payload0", now)

   909   });

   911   let request = client.deleteCollection("testcoll");

   912   request.locallyModifiedVersion = coll.timestamp;

   914   request.dispatch(function onComplete(error, req) {

   915     do_check_null(error);

   917     do_check_eq(user.collection("testcoll"), undefined);

   919     server.stop(run_next_test);

   920   });

   921 });

   923 add_test(function test_delete_collections() {

   924   _("Ensure deleteCollections() works.");

   926   let [server, client, username] = getServerAndClient();

   927   let user = server.user(username);

   929   user.createCollection("testColl", {

   930     foo: new ServerBSO("foo", "payload0", Date.now())

   931   });

   933   let request = client.deleteCollections();

   934   request.dispatch(function onComplete(error, req) {

   935     do_check_null(error);

   937     do_check_eq(user.collection("testcoll"), undefined);

   939     server.stop(run_next_test);

   940   });

   941 });

   943 add_test(function test_network_error_captured() {

   944   _("Ensure network errors are captured.");

   946   // Network errors should result in .networkError being set on request.

   947   let client = new StorageServiceClient("http://rnewman-is-splendid.badtld/");

   949   let request = client.getCollectionInfo();

   950   request.dispatch(function(error, req) {

   951     do_check_neq(error, null);

   952     do_check_neq(error.network, null);

   954     run_next_test();

   955   });

   956 });

   958 add_test(function test_network_error_listener() {

   959   _("Ensure the onNetworkError listener is invoked on network errors.");

   961   let listenerCalled = false;

   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 });

   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.");

   979   let [server, client, username] = getServerAndClient();

   981   let request = client.setBSOsBatching("testcoll");

   982   let payload = "";

   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   }

   990   let bso = new BasicStorageObject("bso");

   991   bso.payload = payload;

   992   do_check_throws(function add() { request.addBSO(bso); });

   994   server.stop(run_next_test);

   995 });

   997 add_test(function test_batching_set_basic() {

   998   _("Ensure batching set works with single requests.");

  1000   let [server, client, username] = getServerAndClient();

  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   }

  1009   request.finish(function onFinish(request) {

  1010     do_check_eq(request.successfulIDs.length, 10);

  1012     let collection = server.user(username).collection("testcoll");

  1013     do_check_eq(collection.timestamp, request.serverModifiedVersion);

  1015     server.stop(run_next_test);

  1016   });

  1017 });

  1019 add_test(function test_batching_set_batch_count() {

  1020   _("Ensure multiple outgoing request batching works when count is exceeded.");

  1022   let [server, client, username] = getServerAndClient();

  1023   let requestCount = 0;

  1024   server.callback.onRequest = function onRequest() {

  1025     requestCount++;

  1026   }

  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   }

  1035   request.finish(function onFinish(request) {

  1036     do_check_eq(request.successfulIDs.length, 300);

  1037     do_check_eq(requestCount, 3);

  1039     let collection = server.user(username).collection("testcoll");

  1040     do_check_eq(collection.timestamp, request.serverModifiedVersion);

  1042     server.stop(run_next_test);

  1043   });

  1044 });

  1046 add_test(function test_batching_set_batch_size() {

  1047   _("Ensure outgoing requests batch when size is exceeded.");

  1049   let [server, client, username] = getServerAndClient();

  1050   let requestCount = 0;

  1051   server.callback.onRequest = function onRequest() {

  1052     requestCount++;

  1053   };

  1055   let limit = client.REQUEST_SIZE_LIMIT;

  1057   let request = client.setBSOsBatching("testcoll");

  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   }

  1065   let payload = data.join("");

  1067   for (let i = 0; i < 4; i++) {

  1068     let bso = new BasicStorageObject("bso" + i);

  1069     bso.payload = payload;

  1070     request.addBSO(bso);

  1071   }

  1073   request.finish(function onFinish(request) {

  1074     do_check_eq(request.successfulIDs.length, 4);

  1075     do_check_eq(requestCount, 2);

  1077     let collection = server.user(username).collection("testcoll");

  1078     do_check_eq(collection.timestamp, request.serverModifiedVersion);

  1080     server.stop(run_next_test);

  1081   });

  1082 });

  1084 add_test(function test_batching_set_flush() {

  1085   _("Ensure flushing batch sets works.");

  1087   let [server, client, username] = getServerAndClient();

  1089   let requestCount = 0;

  1090   server.callback.onRequest = function onRequest() {

  1091     requestCount++;

  1092   }

  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);

  1100     if (i % 10 == 0) {

  1101       request.flush();

  1102     }

  1103   }

  1105   request.finish(function onFinish(request) {

  1106     do_check_eq(request.successfulIDs.length, 100);

  1107     do_check_eq(requestCount, 10);

  1109     let collection = server.user(username).collection("testcoll");

  1110     do_check_eq(collection.timestamp, request.serverModifiedVersion);

  1112     server.stop(run_next_test);

  1113   });

  1114 });

  1116 add_test(function test_batching_set_conditional_success() {

  1117   _("Ensure conditional requests for batched sets work properly.");

  1119   let [server, client, username] = getServerAndClient();

  1121   let collection = server.user(username).createCollection("testcoll");

  1123   let lastServerVersion = Date.now();

  1124   collection.insertBSO(new ServerBSO("foo", "bar", lastServerVersion));

  1125   collection.timestamp = lastServerVersion;

  1126   do_check_eq(collection.timestamp, lastServerVersion);

  1128   let requestCount = 0;

  1129   server.callback.onRequest = function onRequest() {

  1130     requestCount++;

  1131   }

  1133   let request = client.setBSOsBatching("testcoll");

  1134   request.locallyModifiedVersion = collection.timestamp;

  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   }

  1142   request.finish(function onFinish(request) {

  1143     do_check_eq(requestCount, 3);

  1145     do_check_eq(collection.timestamp, request.serverModifiedVersion);

  1146     do_check_eq(collection.timestamp, request.locallyModifiedVersion);

  1148     server.stop(run_next_test);

  1149   });

  1150 });

  1152 add_test(function test_batching_set_initial_failure() {

  1153   _("Ensure that an initial request failure setting BSOs is handled properly.");

  1155   let [server, client, username] = getServerAndClient();

  1157   let collection = server.user(username).createCollection("testcoll");

  1158   collection.timestamp = Date.now();

  1160   let requestCount = 0;

  1161   server.callback.onRequest = function onRequest() {

  1162     requestCount++;

  1163   }

  1165   let request = client.setBSOsBatching("testcoll");

  1166   request.locallyModifiedVersion = collection.timestamp - 1;

  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   }

  1174   request.finish(function onFinish(request) {

  1175     do_check_eq(requestCount, 1);

  1177     do_check_eq(request.successfulIDs.length, 0);

  1178     do_check_eq(Object.keys(request.failures).length, 0);

  1180     server.stop(run_next_test);

  1181   });

  1182 });

  1184 add_test(function test_batching_set_subsequent_failure() {

  1185   _("Ensure a non-initial failure during batching set is handled properly.");

  1187   let [server, client, username] = getServerAndClient();

  1188   let collection = server.user(username).createCollection("testcoll");

  1189   collection.timestamp = Date.now();

  1191   let requestCount = 0;

  1192   server.callback.onRequest = function onRequest() {

  1193     requestCount++;

  1195     if (requestCount == 1) {

  1196       return;

  1197     }

  1199     collection.timestamp++;

  1200   }

  1202   let request = client.setBSOsBatching("testcoll");

  1203   request.locallyModifiedVersion = collection.timestamp;

  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   }

  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);

  1216     server.stop(run_next_test);

  1217   });

  1218 });

  1220 function getBatchedDeleteData(collection="testcoll") {

  1221   let [server, client, username] = getServerAndClient();

  1223   let serverBSOs = {};

  1224   for (let i = 1000; i; i -= 1) {

  1225     serverBSOs["bso" + i] = new ServerBSO("bso" + i, "payload" + i);

  1226   }

  1228   let user = server.user(username);

  1229   user.createCollection(collection, serverBSOs);

  1231   return [server, client, username, collection];

  1232 }

  1234 add_test(function test_batched_delete_single() {

  1235   _("Ensure batched delete with single request works.");

  1237   let [server, client, username, collection] = getBatchedDeleteData();

  1239   let requestCount = 0;

  1240   server.callback.onRequest = function onRequest() {

  1241     requestCount += 1;

  1242   }

  1244   let request = client.deleteBSOsBatching(collection);

  1245   for (let i = 1; i < 51; i += 1) {

  1246     request.addID("bso" + i);

  1247   }

  1249   request.finish(function onFinish(request) {

  1250     do_check_eq(requestCount, 1);

  1251     do_check_eq(request.errors.length, 0);

  1253     let coll = server.user(username).collection(collection);

  1254     do_check_eq(coll.count(), 950);

  1256     do_check_eq(request.serverModifiedVersion, coll.timestamp);

  1258     server.stop(run_next_test);

  1259   });

  1260 });

  1262 add_test(function test_batched_delete_multiple() {

  1263   _("Ensure batched delete splits requests properly.");

  1265   let [server, client, username, collection] = getBatchedDeleteData();

  1267   let requestCount = 0;

  1268   server.callback.onRequest = function onRequest() {

  1269     requestCount += 1;

  1270   }

  1272   let request = client.deleteBSOsBatching(collection);

  1273   for (let i = 1; i < 251; i += 1) {

  1274     request.addID("bso" + i);

  1275   }

  1277   request.finish(function onFinish(request) {

  1278     do_check_eq(requestCount, 3);

  1279     do_check_eq(request.errors.length, 0);

  1281     let coll = server.user(username).collection(collection);

  1282     do_check_eq(coll.count(), 750);

  1284     do_check_eq(request.serverModifiedVersion, coll.timestamp);

  1286     server.stop(run_next_test);

  1287   });

  1288 });

  1290 add_test(function test_batched_delete_conditional_success() {

  1291   _("Ensure conditional batched delete all work.");

  1293   let [server, client, username, collection] = getBatchedDeleteData();

  1295   let requestCount = 0;

  1296   server.callback.onRequest = function onRequest() {

  1297     requestCount++;

  1298   }

  1300   let serverCollection = server.user(username).collection(collection);

  1301   let initialTimestamp = serverCollection.timestamp;

  1303   let request = client.deleteBSOsBatching(collection);

  1304   request.locallyModifiedVersion = initialTimestamp;

  1306   for (let i = 1; i < 251; i += 1) {

  1307     request.addID("bso" + 1);

  1308   }

  1310   request.finish(function onFinish(request) {

  1311     do_check_eq(requestCount, 3);

  1312     do_check_eq(request.errors.length, 0);

  1314     do_check_true(request.locallyModifiedVersion > initialTimestamp);

  1316     server.stop(run_next_test);

  1317   });

  1318 });

  1320 add_test(function test_batched_delete_conditional_initial_failure() {

  1321   _("Ensure conditional batched delete failure on initial request works.");

  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();

  1327   let requestCount = 0;

  1328   server.callback.onRequest = function onRequest() {

  1329     requestCount++;

  1330   }

  1332   let serverCollection = server.user(username).collection(collection);

  1333   let request = client.deleteBSOsBatching(collection);

  1334   request.locallyModifiedVersion = serverCollection.timestamp - 1;

  1336   for (let i = 1; i < 251; i += 1) {

  1337     request.addID("bso" + i);

  1338   }

  1340   request.finish(function onFinish(request) {

  1341     do_check_eq(requestCount, 1);

  1342     do_check_eq(request.errors.length, 1);

  1344     server.stop(run_next_test);

  1345   });

  1346 });

  1348 add_test(function test_batched_delete_conditional_subsequent_failure() {

  1349   _("Ensure conditional batched delete failure on non-initial request.");

  1351   let [server, client, username, collection] = getBatchedDeleteData();

  1353   let serverCollection = server.user(username).collection(collection);

  1355   let requestCount = 0;

  1356   server.callback.onRequest = function onRequest() {

  1357     requestCount++;

  1359     if (requestCount <= 1) {

  1360       return;

  1361     }

  1363     // Advance collection's timestamp on subsequent requests so request is

  1364     // rejected.

  1365     serverCollection.timestamp++;

  1366   }

  1368   let request = client.deleteBSOsBatching(collection);

  1369   request.locallyModifiedVersion = serverCollection.timestamp;

  1371   for (let i = 1; i < 251; i += 1) {

  1372     request.addID("bso" + i);

  1373   }

  1375   request.finish(function onFinish(request) {

  1376     do_check_eq(requestCount, 2);

  1377     do_check_eq(request.errors.length, 1);

  1379     server.stop(run_next_test);

  1380   });

  1381 });

The Tor Browser / file revision

services/common/tests/unit/test_storageservice_client.js@6474c204b198

services/common/tests/unit/test_storageservice_client.js