1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/services/common/tests/unit/test_storageservice_client.js Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1381 @@
1.4 +/* Any copyright is dedicated to the Public Domain.
1.5 + * http://creativecommons.org/publicdomain/zero/1.0/ */
1.6 +
1.7 +Cu.import("resource://services-common/storageservice.js");
1.8 +Cu.import("resource://testing-common/services-common/storageserver.js");
1.9 +
1.10 +function run_test() {
1.11 + initTestLogging("Trace");
1.12 +
1.13 + run_next_test();
1.14 +}
1.15 +
1.16 +function getRandomUser() {
1.17 + return "" + (Math.floor(Math.random() * 100000) + 1);
1.18 +}
1.19 +
1.20 +function getEmptyServer(user=getRandomUser(), password="password") {
1.21 + let users = {};
1.22 + users[user] = password;
1.23 +
1.24 + return storageServerForUsers(users, {
1.25 + meta: {},
1.26 + clients: {},
1.27 + crypto: {},
1.28 + });
1.29 +}
1.30 +
1.31 +function getClient(server, user=getRandomUser(), password="password") {
1.32 + let identity = server.server.identity;
1.33 + let url = identity.primaryScheme + "://" + identity.primaryHost + ":" +
1.34 + identity.primaryPort + "/2.0/" + user;
1.35 + let client = new StorageServiceClient(url);
1.36 + client.addListener({
1.37 + onDispatch: function onDispatch(request) {
1.38 + let up = user + ":" + password;
1.39 + request.request.setHeader("authorization", "Basic " + btoa(up));
1.40 + }
1.41 + });
1.42 +
1.43 + return client;
1.44 +}
1.45 +
1.46 +function getServerAndClient(user=getRandomUser(), password="password") {
1.47 + let server = getEmptyServer(user, password);
1.48 + let client = getClient(server, user, password);
1.49 +
1.50 + return [server, client, user, password];
1.51 +}
1.52 +
1.53 +add_test(function test_auth_failure_listener() {
1.54 + _("Ensure the onAuthFailure listener is invoked.");
1.55 +
1.56 + let server = getEmptyServer();
1.57 + let client = getClient(server, "324", "INVALID");
1.58 + client.addListener({
1.59 + onAuthFailure: function onAuthFailure(client, request) {
1.60 + _("onAuthFailure");
1.61 + server.stop(run_next_test);
1.62 + }
1.63 + });
1.64 +
1.65 + let request = client.getCollectionInfo();
1.66 + request.dispatch();
1.67 +});
1.68 +
1.69 +add_test(function test_duplicate_listeners() {
1.70 + _("Ensure that duplicate listeners aren't installed multiple times.");
1.71 +
1.72 + let server = getEmptyServer();
1.73 + let client = getClient(server, "1234567", "BAD_PASSWORD");
1.74 +
1.75 + let invokeCount = 0;
1.76 + let listener = {
1.77 + onAuthFailure: function onAuthFailure() {
1.78 + invokeCount++;
1.79 + }
1.80 + };
1.81 +
1.82 + client.addListener(listener);
1.83 + // No error expected.
1.84 + client.addListener(listener);
1.85 +
1.86 + let request = client.getCollectionInfo();
1.87 + request.dispatch(function onComplete() {
1.88 + do_check_eq(invokeCount, 1);
1.89 +
1.90 + server.stop(run_next_test);
1.91 + });
1.92 +});
1.93 +
1.94 +add_test(function test_handler_object() {
1.95 + _("Ensure that installed handlers get their callbacks invoked.");
1.96 +
1.97 + let [server, client] = getServerAndClient();
1.98 +
1.99 + let onCompleteCount = 0;
1.100 + let onDispatchCount = 0;
1.101 +
1.102 + let handler = {
1.103 + onComplete: function onComplete() {
1.104 + onCompleteCount++;
1.105 +
1.106 + do_check_eq(onDispatchCount, 1);
1.107 + do_check_eq(onCompleteCount, 1);
1.108 +
1.109 + server.stop(run_next_test);
1.110 + },
1.111 +
1.112 + onDispatch: function onDispatch() {
1.113 + onDispatchCount++;
1.114 + },
1.115 + };
1.116 + let request = client.getCollectionInfo();
1.117 + request.handler = handler;
1.118 + request.dispatch();
1.119 +});
1.120 +
1.121 +add_test(function test_info_collections() {
1.122 + _("Ensure requests to /info/collections work as expected.");
1.123 +
1.124 + let [server, client] = getServerAndClient();
1.125 +
1.126 + let request = client.getCollectionInfo();
1.127 + request.dispatch(function onComplete(error, req) {
1.128 + do_check_null(error);
1.129 + do_check_eq("object", typeof req.resultObj);
1.130 + do_check_attribute_count(req.resultObj, 3);
1.131 + do_check_true("meta" in req.resultObj);
1.132 +
1.133 + server.stop(run_next_test);
1.134 + });
1.135 +});
1.136 +
1.137 +add_test(function test_info_collections_conditional_not_modified() {
1.138 + _("Ensure conditional getCollectionInfo requests work.");
1.139 +
1.140 + let [server, client, username] = getServerAndClient();
1.141 + let user = server.user(username);
1.142 +
1.143 + let now = Date.now();
1.144 +
1.145 + user.createCollection("testcoll", {
1.146 + foo: new ServerBSO("foo", "payload", now)
1.147 + });
1.148 +
1.149 + let request = client.getCollectionInfo();
1.150 + request.locallyModifiedVersion = now + 10;
1.151 + request.dispatch(function onComplete(error, req) {
1.152 + do_check_null(error);
1.153 + do_check_true(req.notModified);
1.154 +
1.155 + server.stop(run_next_test);
1.156 + });
1.157 +});
1.158 +
1.159 +add_test(function test_info_collections_conditional_modified() {
1.160 + _("Ensure conditional getCollectionInfo requests work.");
1.161 +
1.162 + let [server, client, username] = getServerAndClient();
1.163 + let user = server.user(username);
1.164 +
1.165 + let now = Date.now();
1.166 +
1.167 + user.createCollection("testcoll", {
1.168 + foo: new ServerBSO("foo", "payload", now)
1.169 + });
1.170 +
1.171 + let request = client.getCollectionInfo();
1.172 + request.locallyModifiedVersion = now - 10;
1.173 + request.dispatch(function onComplete(error, req) {
1.174 + do_check_null(error);
1.175 + do_check_false(req.notModified);
1.176 +
1.177 + server.stop(run_next_test);
1.178 + });
1.179 +});
1.180 +
1.181 +add_test(function test_get_quota() {
1.182 + _("Ensure quota requests work.");
1.183 +
1.184 + let [server, client] = getServerAndClient();
1.185 +
1.186 + let request = client.getQuota();
1.187 + request.dispatch(function onComplete(error, req) {
1.188 + do_check_null(error);
1.189 +
1.190 + do_check_eq(req.resultObj.quota, 1048576);
1.191 +
1.192 + server.stop(run_next_test);
1.193 + });
1.194 +});
1.195 +
1.196 +add_test(function test_get_quota_conditional_not_modified() {
1.197 + _("Ensure conditional getQuota requests work.");
1.198 +
1.199 + let [server, client, username] = getServerAndClient();
1.200 + let user = server.user(username);
1.201 +
1.202 + let now = Date.now();
1.203 +
1.204 + user.createCollection("testcoll", {
1.205 + foo: new ServerBSO("foo", "payload", now)
1.206 + });
1.207 +
1.208 + let request = client.getQuota();
1.209 + request.locallyModifiedVersion = now + 10;
1.210 + request.dispatch(function onComplete(error, req) {
1.211 + do_check_null(error);
1.212 + do_check_true(req.notModified);
1.213 +
1.214 + server.stop(run_next_test);
1.215 + });
1.216 +});
1.217 +
1.218 +add_test(function test_get_quota_conditional_modified() {
1.219 + _("Ensure conditional getQuota requests work.");
1.220 +
1.221 + let [server, client, username] = getServerAndClient();
1.222 + let user = server.user(username);
1.223 +
1.224 + let now = Date.now();
1.225 +
1.226 + user.createCollection("testcoll", {
1.227 + foo: new ServerBSO("foo", "payload", now)
1.228 + });
1.229 +
1.230 + let request = client.getQuota();
1.231 + request.locallyModifiedVersion = now - 10;
1.232 + request.dispatch(function onComplete(error, req) {
1.233 + do_check_null(error);
1.234 + do_check_false(req.notModified);
1.235 +
1.236 + server.stop(run_next_test);
1.237 + });
1.238 +});
1.239 +
1.240 +add_test(function test_get_collection_usage() {
1.241 + _("Ensure info/collection_usage requests work.");
1.242 +
1.243 + let [server, client, username] = getServerAndClient();
1.244 + let user = server.user(username);
1.245 +
1.246 + user.createCollection("testcoll", {
1.247 + abc123: new ServerBSO("abc123", "payload", Date.now())
1.248 + });
1.249 +
1.250 + let request = client.getCollectionUsage();
1.251 + request.dispatch(function onComplete(error, req) {
1.252 + do_check_null(error);
1.253 +
1.254 + let usage = req.resultObj;
1.255 + do_check_true("testcoll" in usage);
1.256 + do_check_eq(usage.testcoll, "payload".length);
1.257 +
1.258 + server.stop(run_next_test);
1.259 + });
1.260 +});
1.261 +
1.262 +add_test(function test_get_usage_conditional_not_modified() {
1.263 + _("Ensure conditional getCollectionUsage requests work.");
1.264 +
1.265 + let [server, client, username] = getServerAndClient();
1.266 + let user = server.user(username);
1.267 +
1.268 + let now = Date.now();
1.269 +
1.270 + user.createCollection("testcoll", {
1.271 + foo: new ServerBSO("foo", "payload", now)
1.272 + });
1.273 +
1.274 + let request = client.getCollectionUsage();
1.275 + request.locallyModifiedVersion = now + 10;
1.276 + request.dispatch(function onComplete(error, req) {
1.277 + do_check_null(error);
1.278 + do_check_true(req.notModified);
1.279 +
1.280 + server.stop(run_next_test);
1.281 + });
1.282 +});
1.283 +
1.284 +add_test(function test_get_usage_conditional_modified() {
1.285 + _("Ensure conditional getCollectionUsage requests work.");
1.286 +
1.287 + let [server, client, username] = getServerAndClient();
1.288 + let user = server.user(username);
1.289 +
1.290 + let now = Date.now();
1.291 +
1.292 + user.createCollection("testcoll", {
1.293 + foo: new ServerBSO("foo", "payload", now)
1.294 + });
1.295 +
1.296 + let request = client.getCollectionUsage();
1.297 + request.locallyModifiedVersion = now - 10;
1.298 + request.dispatch(function onComplete(error, req) {
1.299 + do_check_null(error);
1.300 + do_check_false(req.notModified);
1.301 +
1.302 + server.stop(run_next_test);
1.303 + });
1.304 +});
1.305 +
1.306 +add_test(function test_get_collection_counts() {
1.307 + _("Ensure info/collection_counts requests work.");
1.308 +
1.309 + let [server, client, username] = getServerAndClient();
1.310 + let user = server.user(username);
1.311 +
1.312 + user.createCollection("testcoll", {
1.313 + foo: new ServerBSO("foo", "payload0", Date.now()),
1.314 + bar: new ServerBSO("bar", "payload1", Date.now())
1.315 + });
1.316 +
1.317 + let request = client.getCollectionCounts();
1.318 + request.dispatch(function onComplete(error, req) {
1.319 + do_check_null(error);
1.320 +
1.321 + let counts = req.resultObj;
1.322 + do_check_true("testcoll" in counts);
1.323 + do_check_eq(counts.testcoll, 2);
1.324 +
1.325 + server.stop(run_next_test);
1.326 + });
1.327 +});
1.328 +
1.329 +add_test(function test_get_counts_conditional_not_modified() {
1.330 + _("Ensure conditional getCollectionCounts requests work.");
1.331 +
1.332 + let [server, client, username] = getServerAndClient();
1.333 + let user = server.user(username);
1.334 +
1.335 + let now = Date.now();
1.336 +
1.337 + user.createCollection("testcoll", {
1.338 + foo: new ServerBSO("foo", "payload", now)
1.339 + });
1.340 +
1.341 + let request = client.getCollectionCounts();
1.342 + request.locallyModifiedVersion = now + 10;
1.343 + request.dispatch(function onComplete(error, req) {
1.344 + do_check_null(error);
1.345 + do_check_true(req.notModified);
1.346 +
1.347 + server.stop(run_next_test);
1.348 + });
1.349 +});
1.350 +
1.351 +add_test(function test_get_counts_conditional_modified() {
1.352 + _("Ensure conditional getCollectionCounts requests work.");
1.353 +
1.354 + let [server, client, username] = getServerAndClient();
1.355 + let user = server.user(username);
1.356 +
1.357 + let now = Date.now();
1.358 +
1.359 + user.createCollection("testcoll", {
1.360 + foo: new ServerBSO("foo", "payload", now)
1.361 + });
1.362 +
1.363 + let request = client.getCollectionCounts();
1.364 + request.locallyModifiedVersion = now - 10;
1.365 + request.dispatch(function onComplete(error, req) {
1.366 + do_check_null(error);
1.367 + do_check_false(req.notModified);
1.368 +
1.369 + server.stop(run_next_test);
1.370 + });
1.371 +});
1.372 +
1.373 +add_test(function test_get_collection_simple() {
1.374 + _("Ensure basic collection retrieval works.");
1.375 +
1.376 + let [server, client, username] = getServerAndClient();
1.377 + let user = server.user(username);
1.378 +
1.379 + user.createCollection("testcoll", {
1.380 + foo: new ServerBSO("foo", "payload0", Date.now()),
1.381 + bar: new ServerBSO("bar", "payload1", Date.now())
1.382 + });
1.383 +
1.384 + let request = client.getCollection("testcoll");
1.385 + let bsos = [];
1.386 + request.handler = {
1.387 + onBSORecord: function onBSORecord(request, bso) {
1.388 + bsos.push(bso);
1.389 + },
1.390 +
1.391 + onComplete: function onComplete(error, request) {
1.392 + do_check_null(error);
1.393 +
1.394 + do_check_eq(bsos.length, 2);
1.395 + do_check_eq(bsos[0], "foo");
1.396 + do_check_eq(bsos[1], "bar");
1.397 +
1.398 + server.stop(run_next_test);
1.399 + }
1.400 + };
1.401 + request.dispatch();
1.402 +});
1.403 +
1.404 +add_test(function test_get_collection_conditional_not_modified() {
1.405 + _("Ensure conditional requests with no new data to getCollection work.");
1.406 +
1.407 + let [server, client, username] = getServerAndClient();
1.408 + let user = server.user(username);
1.409 +
1.410 + let now = Date.now();
1.411 +
1.412 + user.createCollection("testcoll", {
1.413 + foo: new ServerBSO("foo", "payload0", now)
1.414 + });
1.415 +
1.416 + let request = client.getCollection("testcoll");
1.417 + request.locallyModifiedVersion = now + 1;
1.418 +
1.419 + request.dispatch(function onComplete(error, req) {
1.420 + do_check_null(error);
1.421 +
1.422 + do_check_true(req.notModified);
1.423 +
1.424 + server.stop(run_next_test);
1.425 + });
1.426 +});
1.427 +
1.428 +add_test(function test_get_collection_conditional_modified() {
1.429 + _("Ensure conditional requests with new data to getCollection work.");
1.430 +
1.431 + let [server, client, username] = getServerAndClient();
1.432 + let user = server.user(username);
1.433 +
1.434 + let now = Date.now();
1.435 +
1.436 + user.createCollection("testcoll", {
1.437 + foo: new ServerBSO("foo", "payload0", now)
1.438 + });
1.439 +
1.440 + let request = client.getCollection("testcoll");
1.441 + request.locallyModifiedVersion = now - 1;
1.442 +
1.443 + let bsoCount = 0;
1.444 + request.handler = {
1.445 + onBSORecord: function onBSORecord() {
1.446 + bsoCount++;
1.447 + },
1.448 +
1.449 + onComplete: function onComplete(error, req) {
1.450 + do_check_null(error);
1.451 +
1.452 + do_check_false(req.notModified);
1.453 + do_check_eq(bsoCount, 1);
1.454 +
1.455 + server.stop(run_next_test);
1.456 + }
1.457 + };
1.458 + request.dispatch();
1.459 +});
1.460 +
1.461 +// This is effectively a sanity test for query string generation.
1.462 +add_test(function test_get_collection_newer() {
1.463 + _("Ensure query string for newer and full work together.");
1.464 +
1.465 + let [server, client, username] = getServerAndClient();
1.466 +
1.467 + let date0 = Date.now();
1.468 + let date1 = date0 + 500;
1.469 +
1.470 + let user = server.user(username);
1.471 + user.createCollection("testcoll", {
1.472 + foo: new ServerBSO("foo", "payload0", date0),
1.473 + bar: new ServerBSO("bar", "payload1", date1)
1.474 + });
1.475 +
1.476 + let request = client.getCollection("testcoll");
1.477 + request.full = true;
1.478 + request.newer = date0;
1.479 +
1.480 + let bsos = [];
1.481 + request.handler = {
1.482 + onBSORecord: function onBSORecord(request, bso) {
1.483 + bsos.push(bso);
1.484 + },
1.485 +
1.486 + onComplete: function onComplete(error, req) {
1.487 + do_check_null(error);
1.488 +
1.489 + do_check_eq(bsos.length, 1);
1.490 + let bso = bsos[0];
1.491 +
1.492 + do_check_eq(bso.id, "bar");
1.493 + do_check_eq(bso.payload, "payload1");
1.494 +
1.495 + server.stop(run_next_test);
1.496 + }
1.497 + };
1.498 + request.dispatch();
1.499 +});
1.500 +
1.501 +add_test(function test_get_bso() {
1.502 + _("Ensure that simple BSO fetches work.");
1.503 +
1.504 + let [server, client, username] = getServerAndClient();
1.505 +
1.506 + server.createCollection(username, "testcoll", {
1.507 + abc123: new ServerBSO("abc123", "payload", Date.now())
1.508 + });
1.509 +
1.510 + let request = client.getBSO("testcoll", "abc123");
1.511 + request.dispatch(function(error, req) {
1.512 + do_check_null(error);
1.513 + do_check_true(req.resultObj instanceof BasicStorageObject);
1.514 +
1.515 + let bso = req.resultObj;
1.516 + do_check_eq(bso.id, "abc123");
1.517 + do_check_eq(bso.payload, "payload");
1.518 +
1.519 + server.stop(run_next_test);
1.520 + });
1.521 +});
1.522 +
1.523 +add_test(function test_bso_conditional() {
1.524 + _("Ensure conditional requests for an individual BSO work.");
1.525 +
1.526 + let [server, client, username] = getServerAndClient();
1.527 +
1.528 + let user = server.user(username);
1.529 + let now = Date.now();
1.530 + user.createCollection("testcoll", {
1.531 + foo: new ServerBSO("foo", "payload", now)
1.532 + });
1.533 +
1.534 + let request = client.getBSO("testcoll", "foo");
1.535 + request.locallyModifiedVersion = now;
1.536 +
1.537 + request.dispatch(function onComplete(error, req) {
1.538 + do_check_null(error);
1.539 + do_check_true(req.notModified);
1.540 +
1.541 + server.stop(run_next_test);
1.542 + });
1.543 +});
1.544 +
1.545 +add_test(function test_set_bso() {
1.546 + _("Ensure simple BSO PUT works.");
1.547 +
1.548 + let [server, client] = getServerAndClient();
1.549 +
1.550 + let id = "mnas08h3f3r2351";
1.551 +
1.552 + let bso = new BasicStorageObject(id, "testcoll");
1.553 + bso.payload = "my test payload";
1.554 +
1.555 + let request = client.setBSO(bso);
1.556 + request.dispatch(function(error, req) {
1.557 + do_check_eq(error, null);
1.558 + do_check_eq(req.resultObj, null);
1.559 +
1.560 + server.stop(run_next_test);
1.561 + });
1.562 +});
1.563 +
1.564 +
1.565 +add_test(function test_set_bso_conditional() {
1.566 + _("Ensure conditional setting a BSO is properly rejected.");
1.567 +
1.568 + let [server, client, username] = getServerAndClient();
1.569 + let user = server.user(username);
1.570 +
1.571 + let now = Date.now();
1.572 + user.createCollection("testcoll", {
1.573 + foo: new ServerBSO("foo", "payload0", now + 1000)
1.574 + });
1.575 +
1.576 + // Should get an mtime newer than server's.
1.577 + let bso = new BasicStorageObject("foo", "testcoll");
1.578 + bso.payload = "payload1";
1.579 +
1.580 + let request = client.setBSO(bso);
1.581 + request.locallyModifiedVersion = now;
1.582 + request.dispatch(function onComplete(error, req) {
1.583 + do_check_true(error instanceof StorageServiceRequestError);
1.584 + do_check_true(error.serverModified);
1.585 +
1.586 + server.stop(run_next_test);
1.587 + });
1.588 +});
1.589 +
1.590 +add_test(function test_set_bso_argument_errors() {
1.591 + _("Ensure BSO set detects invalid arguments.");
1.592 +
1.593 + let server = getEmptyServer();
1.594 + let bso = new BasicStorageObject();
1.595 + let client = getClient(server);
1.596 +
1.597 + let threw = false;
1.598 + try {
1.599 + client.setBSO(bso);
1.600 + } catch (ex) {
1.601 + threw = true;
1.602 + do_check_eq(ex.name, "Error");
1.603 + do_check_neq(ex.message.indexOf("does not have collection defined"), -1);
1.604 + } finally {
1.605 + do_check_true(threw);
1.606 + threw = false;
1.607 + }
1.608 +
1.609 + bso = new BasicStorageObject("id");
1.610 + try {
1.611 + client.setBSO(bso);
1.612 + } catch (ex) {
1.613 + threw = true;
1.614 + do_check_eq(ex.name, "Error");
1.615 + do_check_neq(ex.message.indexOf("does not have collection defined"), -1);
1.616 + } finally {
1.617 + do_check_true(threw);
1.618 + threw = false;
1.619 + }
1.620 +
1.621 + bso = new BasicStorageObject(null, "coll");
1.622 + try {
1.623 + client.setBSO(bso);
1.624 + } catch (ex) {
1.625 + threw = true;
1.626 + do_check_eq(ex.name, "Error");
1.627 + do_check_neq(ex.message.indexOf("does not have ID defined"), -1);
1.628 + } finally {
1.629 + do_check_true(threw);
1.630 + threw = false;
1.631 + }
1.632 +
1.633 + server.stop(run_next_test);
1.634 +});
1.635 +
1.636 +add_test(function test_set_bsos_simple() {
1.637 + _("Ensure setBSOs with basic options works.");
1.638 +
1.639 + let [server, client, username] = getServerAndClient();
1.640 + let user = server.user(username);
1.641 +
1.642 + let bso0 = new BasicStorageObject("foo");
1.643 + bso0.payload = "payload0";
1.644 +
1.645 + let bso1 = new BasicStorageObject("bar");
1.646 + bso1.payload = "payload1";
1.647 +
1.648 + let request = client.setBSOs("testcollection");
1.649 + request.addBSO(bso0);
1.650 + request.addBSO(bso1);
1.651 +
1.652 + request.dispatch(function onComplete(error, req) {
1.653 + do_check_null(error);
1.654 +
1.655 + let successful = req.successfulIDs;
1.656 + do_check_eq(successful.length, 2);
1.657 + do_check_eq(successful.indexOf(bso0.id), 0);
1.658 + do_check_true(successful.indexOf(bso1.id), 1);
1.659 +
1.660 + server.stop(run_next_test);
1.661 + });
1.662 +});
1.663 +
1.664 +add_test(function test_set_bsos_invalid_bso() {
1.665 + _("Ensure that adding an invalid BSO throws.");
1.666 +
1.667 + let server = getEmptyServer();
1.668 + let client = getClient(server);
1.669 + let request = client.setBSOs("testcoll");
1.670 +
1.671 + let threw = false;
1.672 +
1.673 + // Empty argument is invalid.
1.674 + try {
1.675 + request.addBSO(null);
1.676 + } catch (ex) {
1.677 + threw = true;
1.678 + } finally {
1.679 + do_check_true(threw);
1.680 + threw = false;
1.681 + }
1.682 +
1.683 + try {
1.684 + let bso = new BasicStorageObject();
1.685 + request.addBSO(bso);
1.686 + } catch (ex) {
1.687 + threw = true;
1.688 + } finally {
1.689 + do_check_true(threw);
1.690 + threw = false;
1.691 + }
1.692 +
1.693 + server.stop(run_next_test);
1.694 +});
1.695 +
1.696 +add_test(function test_set_bsos_newline() {
1.697 + _("Ensure that newlines in BSO payloads are formatted properly.");
1.698 +
1.699 + let [server, client, username] = getServerAndClient();
1.700 + let user = server.user(username);
1.701 +
1.702 + let request = client.setBSOs("testcoll");
1.703 +
1.704 + let bso0 = new BasicStorageObject("bso0");
1.705 + bso0.payload = "hello\nworld";
1.706 + request.addBSO(bso0);
1.707 +
1.708 + let bso1 = new BasicStorageObject("bso1");
1.709 + bso1.payload = "foobar";
1.710 + request.addBSO(bso1);
1.711 +
1.712 + request.dispatch(function onComplete(error, request) {
1.713 + do_check_null(error);
1.714 + do_check_eq(request.successfulIDs.length, 2);
1.715 +
1.716 + let coll = user.collection("testcoll");
1.717 + do_check_eq(coll.bso("bso0").payload, bso0.payload);
1.718 + do_check_eq(coll.bso("bso1").payload, bso1.payload);
1.719 +
1.720 + server.stop(run_next_test);
1.721 + });
1.722 +});
1.723 +
1.724 +add_test(function test_delete_bso_simple() {
1.725 + _("Ensure deletion of individual BSOs works.");
1.726 +
1.727 + let [server, client, username] = getServerAndClient();
1.728 +
1.729 + let user = server.user(username);
1.730 + let coll = user.createCollection("testcoll", {
1.731 + foo: new ServerBSO("foo", "payload0", Date.now()),
1.732 + bar: new ServerBSO("bar", "payload1", Date.now())
1.733 + });
1.734 +
1.735 + let request = client.deleteBSO("testcoll", "foo");
1.736 + request.dispatch(function onComplete(error, req) {
1.737 + do_check_null(error);
1.738 + do_check_eq(req.statusCode, 204);
1.739 +
1.740 + do_check_eq(coll.count(), 1);
1.741 +
1.742 + server.stop(run_next_test);
1.743 + });
1.744 +});
1.745 +
1.746 +add_test(function test_delete_bso_conditional_failed() {
1.747 + _("Ensure deletion of an individual BSO with older modification fails.");
1.748 +
1.749 + let [server, client, username] = getServerAndClient();
1.750 + let user = server.user(username);
1.751 +
1.752 + let now = Date.now();
1.753 + user.createCollection("testcoll", {
1.754 + foo: new ServerBSO("foo", "payload0", now)
1.755 + });
1.756 +
1.757 + let request = client.deleteBSO("testcoll", "foo");
1.758 + request.locallyModifiedVersion = now - 10;
1.759 +
1.760 + request.dispatch(function onComplete(error, req) {
1.761 + do_check_true(error instanceof StorageServiceRequestError);
1.762 + do_check_true(error.serverModified);
1.763 +
1.764 + server.stop(run_next_test);
1.765 + });
1.766 +});
1.767 +
1.768 +add_test(function test_delete_bso_conditional_success() {
1.769 + _("Ensure deletion of an individual BSO with newer modification works.");
1.770 +
1.771 + let [server, client, username] = getServerAndClient();
1.772 + let user = server.user(username);
1.773 +
1.774 + let now = Date.now();
1.775 + user.createCollection("testcoll", {
1.776 + foo: new ServerBSO("foo", "payload0", now)
1.777 + });
1.778 +
1.779 + let request = client.deleteBSO("testcoll", "foo");
1.780 + request.locallyModifiedVersion = now;
1.781 +
1.782 + request.dispatch(function onComplete(error, req) {
1.783 + do_check_null(error);
1.784 + do_check_eq(req.statusCode, 204);
1.785 +
1.786 + server.stop(run_next_test);
1.787 + });
1.788 +});
1.789 +
1.790 +add_test(function test_delete_bsos_simple() {
1.791 + _("Ensure deletion of multiple BSOs works.");
1.792 +
1.793 + let [server, client, username] = getServerAndClient();
1.794 + let user = server.user(username);
1.795 +
1.796 + let coll = user.createCollection("testcoll", {
1.797 + foo: new ServerBSO("foo", "payload0", Date.now()),
1.798 + bar: new ServerBSO("bar", "payload1", Date.now()),
1.799 + baz: new ServerBSO("baz", "payload2", Date.now())
1.800 + });
1.801 +
1.802 + let request = client.deleteBSOs("testcoll", ["foo", "baz"]);
1.803 + request.dispatch(function onComplete(error, req) {
1.804 + do_check_null(error);
1.805 + do_check_eq(req.statusCode, 204);
1.806 +
1.807 + do_check_eq(coll.count(), 1);
1.808 +
1.809 + server.stop(run_next_test);
1.810 + });
1.811 +});
1.812 +
1.813 +add_test(function test_delete_bsos_conditional_failed() {
1.814 + _("Ensure deletion of BSOs with server modifications fails.");
1.815 +
1.816 + let [server, client, username] = getServerAndClient();
1.817 + let user = server.user(username);
1.818 +
1.819 + let now = Date.now();
1.820 + let coll = user.createCollection("testcoll", {
1.821 + foo: new ServerBSO("foo", "payload0", now)
1.822 + });
1.823 +
1.824 + let request = client.deleteBSOs("testcoll", ["foo"]);
1.825 + request.locallyModifiedVersion = coll.timestamp - 1;
1.826 +
1.827 + request.dispatch(function onComplete(error, req) {
1.828 + do_check_true(error instanceof StorageServiceRequestError);
1.829 + do_check_true(error.serverModified);
1.830 +
1.831 + server.stop(run_next_test);
1.832 + });
1.833 +});
1.834 +
1.835 +add_test(function test_delete_bsos_conditional_success() {
1.836 + _("Ensure conditional deletion of BSOs without server modifications works.");
1.837 +
1.838 + let [server, client, username] = getServerAndClient();
1.839 + let user = server.user(username);
1.840 +
1.841 + let now = Date.now();
1.842 + let coll = user.createCollection("testcoll", {
1.843 + foo: new ServerBSO("foo", "payload0", now),
1.844 + bar: new ServerBSO("bar", "payload1", now - 10)
1.845 + });
1.846 +
1.847 + let request = client.deleteBSOs("testcoll", ["bar"]);
1.848 + request.locallyModifiedVersion = coll.timestamp;
1.849 +
1.850 + request.dispatch(function onComplete(error, req) {
1.851 + do_check_null(error);
1.852 +
1.853 + do_check_eq(req.statusCode, 204);
1.854 +
1.855 + server.stop(run_next_test);
1.856 + });
1.857 +});
1.858 +
1.859 +add_test(function test_delete_collection() {
1.860 + _("Ensure deleteCollection() works.");
1.861 +
1.862 + let [server, client, username] = getServerAndClient();
1.863 + let user = server.user(username);
1.864 +
1.865 + user.createCollection("testcoll", {
1.866 + foo: new ServerBSO("foo", "payload0", Date.now())
1.867 + });
1.868 +
1.869 + let request = client.deleteCollection("testcoll");
1.870 + request.dispatch(function onComplete(error, req) {
1.871 + do_check_null(error);
1.872 +
1.873 + do_check_eq(user.collection("testcoll", undefined));
1.874 +
1.875 + server.stop(run_next_test);
1.876 + });
1.877 +});
1.878 +
1.879 +add_test(function test_delete_collection_conditional_failed() {
1.880 + _("Ensure conditional deletes with server modifications fail.");
1.881 +
1.882 + let [server, client, username] = getServerAndClient();
1.883 + let user = server.user(username);
1.884 +
1.885 + let now = Date.now();
1.886 +
1.887 + let coll = user.createCollection("testcoll", {
1.888 + foo: new ServerBSO("foo", "payload0", now)
1.889 + });
1.890 +
1.891 + let request = client.deleteCollection("testcoll");
1.892 + request.locallyModifiedVersion = coll.timestamp - 1;
1.893 +
1.894 + request.dispatch(function onComplete(error, req) {
1.895 + do_check_true(error instanceof StorageServiceRequestError);
1.896 + do_check_true(error.serverModified);
1.897 +
1.898 + server.stop(run_next_test);
1.899 + });
1.900 +});
1.901 +
1.902 +add_test(function test_delete_collection_conditional_success() {
1.903 + _("Ensure conditional delete of collection works when it's supposed to.");
1.904 +
1.905 + let [server, client, username] = getServerAndClient();
1.906 + let user = server.user(username);
1.907 +
1.908 + let now = Date.now();
1.909 +
1.910 + let coll = user.createCollection("testcoll", {
1.911 + foo: new ServerBSO("foo", "payload0", now)
1.912 + });
1.913 +
1.914 + let request = client.deleteCollection("testcoll");
1.915 + request.locallyModifiedVersion = coll.timestamp;
1.916 +
1.917 + request.dispatch(function onComplete(error, req) {
1.918 + do_check_null(error);
1.919 +
1.920 + do_check_eq(user.collection("testcoll"), undefined);
1.921 +
1.922 + server.stop(run_next_test);
1.923 + });
1.924 +});
1.925 +
1.926 +add_test(function test_delete_collections() {
1.927 + _("Ensure deleteCollections() works.");
1.928 +
1.929 + let [server, client, username] = getServerAndClient();
1.930 + let user = server.user(username);
1.931 +
1.932 + user.createCollection("testColl", {
1.933 + foo: new ServerBSO("foo", "payload0", Date.now())
1.934 + });
1.935 +
1.936 + let request = client.deleteCollections();
1.937 + request.dispatch(function onComplete(error, req) {
1.938 + do_check_null(error);
1.939 +
1.940 + do_check_eq(user.collection("testcoll"), undefined);
1.941 +
1.942 + server.stop(run_next_test);
1.943 + });
1.944 +});
1.945 +
1.946 +add_test(function test_network_error_captured() {
1.947 + _("Ensure network errors are captured.");
1.948 +
1.949 + // Network errors should result in .networkError being set on request.
1.950 + let client = new StorageServiceClient("http://rnewman-is-splendid.badtld/");
1.951 +
1.952 + let request = client.getCollectionInfo();
1.953 + request.dispatch(function(error, req) {
1.954 + do_check_neq(error, null);
1.955 + do_check_neq(error.network, null);
1.956 +
1.957 + run_next_test();
1.958 + });
1.959 +});
1.960 +
1.961 +add_test(function test_network_error_listener() {
1.962 + _("Ensure the onNetworkError listener is invoked on network errors.");
1.963 +
1.964 + let listenerCalled = false;
1.965 +
1.966 + let client = new StorageServiceClient("http://philikon-is-too.badtld/");
1.967 + client.addListener({
1.968 + onNetworkError: function(client, request) {
1.969 + listenerCalled = true;
1.970 + }
1.971 + });
1.972 + let request = client.getCollectionInfo();
1.973 + request.dispatch(function() {
1.974 + do_check_true(listenerCalled);
1.975 + run_next_test();
1.976 + });
1.977 +});
1.978 +
1.979 +add_test(function test_batching_set_too_large() {
1.980 + _("Ensure we throw when attempting to add a BSO that is too large to fit.");
1.981 +
1.982 + let [server, client, username] = getServerAndClient();
1.983 +
1.984 + let request = client.setBSOsBatching("testcoll");
1.985 + let payload = "";
1.986 +
1.987 + // The actual length of the payload is a little less. But, this ensures we
1.988 + // exceed it.
1.989 + for (let i = 0; i < client.REQUEST_SIZE_LIMIT; i++) {
1.990 + payload += i;
1.991 + }
1.992 +
1.993 + let bso = new BasicStorageObject("bso");
1.994 + bso.payload = payload;
1.995 + do_check_throws(function add() { request.addBSO(bso); });
1.996 +
1.997 + server.stop(run_next_test);
1.998 +});
1.999 +
1.1000 +add_test(function test_batching_set_basic() {
1.1001 + _("Ensure batching set works with single requests.");
1.1002 +
1.1003 + let [server, client, username] = getServerAndClient();
1.1004 +
1.1005 + let request = client.setBSOsBatching("testcoll");
1.1006 + for (let i = 0; i < 10; i++) {
1.1007 + let bso = new BasicStorageObject("bso" + i);
1.1008 + bso.payload = "payload" + i;
1.1009 + request.addBSO(bso);
1.1010 + }
1.1011 +
1.1012 + request.finish(function onFinish(request) {
1.1013 + do_check_eq(request.successfulIDs.length, 10);
1.1014 +
1.1015 + let collection = server.user(username).collection("testcoll");
1.1016 + do_check_eq(collection.timestamp, request.serverModifiedVersion);
1.1017 +
1.1018 + server.stop(run_next_test);
1.1019 + });
1.1020 +});
1.1021 +
1.1022 +add_test(function test_batching_set_batch_count() {
1.1023 + _("Ensure multiple outgoing request batching works when count is exceeded.");
1.1024 +
1.1025 + let [server, client, username] = getServerAndClient();
1.1026 + let requestCount = 0;
1.1027 + server.callback.onRequest = function onRequest() {
1.1028 + requestCount++;
1.1029 + }
1.1030 +
1.1031 + let request = client.setBSOsBatching("testcoll");
1.1032 + for (let i = 1; i <= 300; i++) {
1.1033 + let bso = new BasicStorageObject("bso" + i);
1.1034 + bso.payload = "XXXXXXX";
1.1035 + request.addBSO(bso);
1.1036 + }
1.1037 +
1.1038 + request.finish(function onFinish(request) {
1.1039 + do_check_eq(request.successfulIDs.length, 300);
1.1040 + do_check_eq(requestCount, 3);
1.1041 +
1.1042 + let collection = server.user(username).collection("testcoll");
1.1043 + do_check_eq(collection.timestamp, request.serverModifiedVersion);
1.1044 +
1.1045 + server.stop(run_next_test);
1.1046 + });
1.1047 +});
1.1048 +
1.1049 +add_test(function test_batching_set_batch_size() {
1.1050 + _("Ensure outgoing requests batch when size is exceeded.");
1.1051 +
1.1052 + let [server, client, username] = getServerAndClient();
1.1053 + let requestCount = 0;
1.1054 + server.callback.onRequest = function onRequest() {
1.1055 + requestCount++;
1.1056 + };
1.1057 +
1.1058 + let limit = client.REQUEST_SIZE_LIMIT;
1.1059 +
1.1060 + let request = client.setBSOsBatching("testcoll");
1.1061 +
1.1062 + // JavaScript: Y U NO EASY REPETITION FUNCTIONALITY?
1.1063 + let data = [];
1.1064 + for (let i = (limit / 2) - 100; i; i -= 1) {
1.1065 + data.push("X");
1.1066 + }
1.1067 +
1.1068 + let payload = data.join("");
1.1069 +
1.1070 + for (let i = 0; i < 4; i++) {
1.1071 + let bso = new BasicStorageObject("bso" + i);
1.1072 + bso.payload = payload;
1.1073 + request.addBSO(bso);
1.1074 + }
1.1075 +
1.1076 + request.finish(function onFinish(request) {
1.1077 + do_check_eq(request.successfulIDs.length, 4);
1.1078 + do_check_eq(requestCount, 2);
1.1079 +
1.1080 + let collection = server.user(username).collection("testcoll");
1.1081 + do_check_eq(collection.timestamp, request.serverModifiedVersion);
1.1082 +
1.1083 + server.stop(run_next_test);
1.1084 + });
1.1085 +});
1.1086 +
1.1087 +add_test(function test_batching_set_flush() {
1.1088 + _("Ensure flushing batch sets works.");
1.1089 +
1.1090 + let [server, client, username] = getServerAndClient();
1.1091 +
1.1092 + let requestCount = 0;
1.1093 + server.callback.onRequest = function onRequest() {
1.1094 + requestCount++;
1.1095 + }
1.1096 +
1.1097 + let request = client.setBSOsBatching("testcoll");
1.1098 + for (let i = 1; i < 101; i++) {
1.1099 + let bso = new BasicStorageObject("bso" + i);
1.1100 + bso.payload = "foo";
1.1101 + request.addBSO(bso);
1.1102 +
1.1103 + if (i % 10 == 0) {
1.1104 + request.flush();
1.1105 + }
1.1106 + }
1.1107 +
1.1108 + request.finish(function onFinish(request) {
1.1109 + do_check_eq(request.successfulIDs.length, 100);
1.1110 + do_check_eq(requestCount, 10);
1.1111 +
1.1112 + let collection = server.user(username).collection("testcoll");
1.1113 + do_check_eq(collection.timestamp, request.serverModifiedVersion);
1.1114 +
1.1115 + server.stop(run_next_test);
1.1116 + });
1.1117 +});
1.1118 +
1.1119 +add_test(function test_batching_set_conditional_success() {
1.1120 + _("Ensure conditional requests for batched sets work properly.");
1.1121 +
1.1122 + let [server, client, username] = getServerAndClient();
1.1123 +
1.1124 + let collection = server.user(username).createCollection("testcoll");
1.1125 +
1.1126 + let lastServerVersion = Date.now();
1.1127 + collection.insertBSO(new ServerBSO("foo", "bar", lastServerVersion));
1.1128 + collection.timestamp = lastServerVersion;
1.1129 + do_check_eq(collection.timestamp, lastServerVersion);
1.1130 +
1.1131 + let requestCount = 0;
1.1132 + server.callback.onRequest = function onRequest() {
1.1133 + requestCount++;
1.1134 + }
1.1135 +
1.1136 + let request = client.setBSOsBatching("testcoll");
1.1137 + request.locallyModifiedVersion = collection.timestamp;
1.1138 +
1.1139 + for (let i = 1; i < 251; i++) {
1.1140 + let bso = new BasicStorageObject("bso" + i);
1.1141 + bso.payload = "foo" + i;
1.1142 + request.addBSO(bso);
1.1143 + }
1.1144 +
1.1145 + request.finish(function onFinish(request) {
1.1146 + do_check_eq(requestCount, 3);
1.1147 +
1.1148 + do_check_eq(collection.timestamp, request.serverModifiedVersion);
1.1149 + do_check_eq(collection.timestamp, request.locallyModifiedVersion);
1.1150 +
1.1151 + server.stop(run_next_test);
1.1152 + });
1.1153 +});
1.1154 +
1.1155 +add_test(function test_batching_set_initial_failure() {
1.1156 + _("Ensure that an initial request failure setting BSOs is handled properly.");
1.1157 +
1.1158 + let [server, client, username] = getServerAndClient();
1.1159 +
1.1160 + let collection = server.user(username).createCollection("testcoll");
1.1161 + collection.timestamp = Date.now();
1.1162 +
1.1163 + let requestCount = 0;
1.1164 + server.callback.onRequest = function onRequest() {
1.1165 + requestCount++;
1.1166 + }
1.1167 +
1.1168 + let request = client.setBSOsBatching("testcoll");
1.1169 + request.locallyModifiedVersion = collection.timestamp - 1;
1.1170 +
1.1171 + for (let i = 1; i < 250; i++) {
1.1172 + let bso = new BasicStorageObject("bso" + i);
1.1173 + bso.payload = "foo" + i;
1.1174 + request.addBSO(bso);
1.1175 + }
1.1176 +
1.1177 + request.finish(function onFinish(request) {
1.1178 + do_check_eq(requestCount, 1);
1.1179 +
1.1180 + do_check_eq(request.successfulIDs.length, 0);
1.1181 + do_check_eq(Object.keys(request.failures).length, 0);
1.1182 +
1.1183 + server.stop(run_next_test);
1.1184 + });
1.1185 +});
1.1186 +
1.1187 +add_test(function test_batching_set_subsequent_failure() {
1.1188 + _("Ensure a non-initial failure during batching set is handled properly.");
1.1189 +
1.1190 + let [server, client, username] = getServerAndClient();
1.1191 + let collection = server.user(username).createCollection("testcoll");
1.1192 + collection.timestamp = Date.now();
1.1193 +
1.1194 + let requestCount = 0;
1.1195 + server.callback.onRequest = function onRequest() {
1.1196 + requestCount++;
1.1197 +
1.1198 + if (requestCount == 1) {
1.1199 + return;
1.1200 + }
1.1201 +
1.1202 + collection.timestamp++;
1.1203 + }
1.1204 +
1.1205 + let request = client.setBSOsBatching("testcoll");
1.1206 + request.locallyModifiedVersion = collection.timestamp;
1.1207 +
1.1208 + for (let i = 0; i < 250; i++) {
1.1209 + let bso = new BasicStorageObject("bso" + i);
1.1210 + bso.payload = "foo" + i;
1.1211 + request.addBSO(bso);
1.1212 + }
1.1213 +
1.1214 + request.finish(function onFinish(request) {
1.1215 + do_check_eq(requestCount, 2);
1.1216 + do_check_eq(request.successfulIDs.length, 100);
1.1217 + do_check_eq(Object.keys(request.failures).length, 0);
1.1218 +
1.1219 + server.stop(run_next_test);
1.1220 + });
1.1221 +});
1.1222 +
1.1223 +function getBatchedDeleteData(collection="testcoll") {
1.1224 + let [server, client, username] = getServerAndClient();
1.1225 +
1.1226 + let serverBSOs = {};
1.1227 + for (let i = 1000; i; i -= 1) {
1.1228 + serverBSOs["bso" + i] = new ServerBSO("bso" + i, "payload" + i);
1.1229 + }
1.1230 +
1.1231 + let user = server.user(username);
1.1232 + user.createCollection(collection, serverBSOs);
1.1233 +
1.1234 + return [server, client, username, collection];
1.1235 +}
1.1236 +
1.1237 +add_test(function test_batched_delete_single() {
1.1238 + _("Ensure batched delete with single request works.");
1.1239 +
1.1240 + let [server, client, username, collection] = getBatchedDeleteData();
1.1241 +
1.1242 + let requestCount = 0;
1.1243 + server.callback.onRequest = function onRequest() {
1.1244 + requestCount += 1;
1.1245 + }
1.1246 +
1.1247 + let request = client.deleteBSOsBatching(collection);
1.1248 + for (let i = 1; i < 51; i += 1) {
1.1249 + request.addID("bso" + i);
1.1250 + }
1.1251 +
1.1252 + request.finish(function onFinish(request) {
1.1253 + do_check_eq(requestCount, 1);
1.1254 + do_check_eq(request.errors.length, 0);
1.1255 +
1.1256 + let coll = server.user(username).collection(collection);
1.1257 + do_check_eq(coll.count(), 950);
1.1258 +
1.1259 + do_check_eq(request.serverModifiedVersion, coll.timestamp);
1.1260 +
1.1261 + server.stop(run_next_test);
1.1262 + });
1.1263 +});
1.1264 +
1.1265 +add_test(function test_batched_delete_multiple() {
1.1266 + _("Ensure batched delete splits requests properly.");
1.1267 +
1.1268 + let [server, client, username, collection] = getBatchedDeleteData();
1.1269 +
1.1270 + let requestCount = 0;
1.1271 + server.callback.onRequest = function onRequest() {
1.1272 + requestCount += 1;
1.1273 + }
1.1274 +
1.1275 + let request = client.deleteBSOsBatching(collection);
1.1276 + for (let i = 1; i < 251; i += 1) {
1.1277 + request.addID("bso" + i);
1.1278 + }
1.1279 +
1.1280 + request.finish(function onFinish(request) {
1.1281 + do_check_eq(requestCount, 3);
1.1282 + do_check_eq(request.errors.length, 0);
1.1283 +
1.1284 + let coll = server.user(username).collection(collection);
1.1285 + do_check_eq(coll.count(), 750);
1.1286 +
1.1287 + do_check_eq(request.serverModifiedVersion, coll.timestamp);
1.1288 +
1.1289 + server.stop(run_next_test);
1.1290 + });
1.1291 +});
1.1292 +
1.1293 +add_test(function test_batched_delete_conditional_success() {
1.1294 + _("Ensure conditional batched delete all work.");
1.1295 +
1.1296 + let [server, client, username, collection] = getBatchedDeleteData();
1.1297 +
1.1298 + let requestCount = 0;
1.1299 + server.callback.onRequest = function onRequest() {
1.1300 + requestCount++;
1.1301 + }
1.1302 +
1.1303 + let serverCollection = server.user(username).collection(collection);
1.1304 + let initialTimestamp = serverCollection.timestamp;
1.1305 +
1.1306 + let request = client.deleteBSOsBatching(collection);
1.1307 + request.locallyModifiedVersion = initialTimestamp;
1.1308 +
1.1309 + for (let i = 1; i < 251; i += 1) {
1.1310 + request.addID("bso" + 1);
1.1311 + }
1.1312 +
1.1313 + request.finish(function onFinish(request) {
1.1314 + do_check_eq(requestCount, 3);
1.1315 + do_check_eq(request.errors.length, 0);
1.1316 +
1.1317 + do_check_true(request.locallyModifiedVersion > initialTimestamp);
1.1318 +
1.1319 + server.stop(run_next_test);
1.1320 + });
1.1321 +});
1.1322 +
1.1323 +add_test(function test_batched_delete_conditional_initial_failure() {
1.1324 + _("Ensure conditional batched delete failure on initial request works.");
1.1325 +
1.1326 + // The client needs to issue multiple requests but the first one was
1.1327 + // rejected. The client should only issue that initial request.
1.1328 + let [server, client, username, collection] = getBatchedDeleteData();
1.1329 +
1.1330 + let requestCount = 0;
1.1331 + server.callback.onRequest = function onRequest() {
1.1332 + requestCount++;
1.1333 + }
1.1334 +
1.1335 + let serverCollection = server.user(username).collection(collection);
1.1336 + let request = client.deleteBSOsBatching(collection);
1.1337 + request.locallyModifiedVersion = serverCollection.timestamp - 1;
1.1338 +
1.1339 + for (let i = 1; i < 251; i += 1) {
1.1340 + request.addID("bso" + i);
1.1341 + }
1.1342 +
1.1343 + request.finish(function onFinish(request) {
1.1344 + do_check_eq(requestCount, 1);
1.1345 + do_check_eq(request.errors.length, 1);
1.1346 +
1.1347 + server.stop(run_next_test);
1.1348 + });
1.1349 +});
1.1350 +
1.1351 +add_test(function test_batched_delete_conditional_subsequent_failure() {
1.1352 + _("Ensure conditional batched delete failure on non-initial request.");
1.1353 +
1.1354 + let [server, client, username, collection] = getBatchedDeleteData();
1.1355 +
1.1356 + let serverCollection = server.user(username).collection(collection);
1.1357 +
1.1358 + let requestCount = 0;
1.1359 + server.callback.onRequest = function onRequest() {
1.1360 + requestCount++;
1.1361 +
1.1362 + if (requestCount <= 1) {
1.1363 + return;
1.1364 + }
1.1365 +
1.1366 + // Advance collection's timestamp on subsequent requests so request is
1.1367 + // rejected.
1.1368 + serverCollection.timestamp++;
1.1369 + }
1.1370 +
1.1371 + let request = client.deleteBSOsBatching(collection);
1.1372 + request.locallyModifiedVersion = serverCollection.timestamp;
1.1373 +
1.1374 + for (let i = 1; i < 251; i += 1) {
1.1375 + request.addID("bso" + i);
1.1376 + }
1.1377 +
1.1378 + request.finish(function onFinish(request) {
1.1379 + do_check_eq(requestCount, 2);
1.1380 + do_check_eq(request.errors.length, 1);
1.1381 +
1.1382 + server.stop(run_next_test);
1.1383 + });
1.1384 +});
