The Tor Browser: services/common/tests/unit/test_storage_server.js@6474c204b198 (annotated)

services/common/tests/unit/test_storage_server.js@6474c204b198 (annotated)

services/common/tests/unit/test_storage_server.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

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

 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 Cu.import("resource://services-common/async.js");
 Cu.import("resource://services-common/rest.js");
 Cu.import("resource://services-common/utils.js");
 Cu.import("resource://testing-common/services-common/storageserver.js");
 const DEFAULT_USER = "123";
 const DEFAULT_PASSWORD = "password";
 /**
  * Helper function to prepare a RESTRequest against the server.
  */
 function localRequest(server, path, user=DEFAULT_USER, password=DEFAULT_PASSWORD) {
   _("localRequest: " + path);
   let identity = server.server.identity;
   let url = identity.primaryScheme + "://" + identity.primaryHost + ":" +
             identity.primaryPort + path;
   _("url: " + url);
   let req = new RESTRequest(url);
   let header = basic_auth_header(user, password);
   req.setHeader("Authorization", header);
   req.setHeader("Accept", "application/json");
   return req;
 }
 /**
  * Helper function to validate an HTTP response from the server.
  */
 function validateResponse(response) {
   do_check_true("x-timestamp" in response.headers);
   if ("content-length" in response.headers) {
     let cl = parseInt(response.headers["content-length"]);
     if (cl != 0) {
       do_check_true("content-type" in response.headers);
       do_check_eq("application/json", response.headers["content-type"]);
     }
   }
   if (response.status == 204 || response.status == 304) {
     do_check_false("content-type" in response.headers);
     if ("content-length" in response.headers) {
       do_check_eq(response.headers["content-length"], "0");
     }
   }
   if (response.status == 405) {
     do_check_true("allow" in response.headers);
   }
 }
 /**
  * Helper function to synchronously wait for a response and validate it.
  */
 function waitAndValidateResponse(cb, request) {
   let error = cb.wait();
   if (!error) {
     validateResponse(request.response);
   }
   return error;
 }
 /**
  * Helper function to synchronously perform a GET request.
  *
  * @return Error instance or null if no error.
  */
 function doGetRequest(request) {
   let cb = Async.makeSpinningCallback();
   request.get(cb);
   return waitAndValidateResponse(cb, request);
 }
 /**
  * Helper function to synchronously perform a PUT request.
  *
  * @return Error instance or null if no error.
  */
 function doPutRequest(request, data) {
   let cb = Async.makeSpinningCallback();
   request.put(data, cb);
   return waitAndValidateResponse(cb, request);
 }
 /**
  * Helper function to synchronously perform a DELETE request.
  *
  * @return Error or null if no error was encountered.
  */
 function doDeleteRequest(request) {
   let cb = Async.makeSpinningCallback();
   request.delete(cb);
   return waitAndValidateResponse(cb, request);
 }
 function run_test() {
   Log.repository.getLogger("Services.Common.Test.StorageServer").level =
     Log.Level.Trace;
   initTestLogging();
   run_next_test();
 }
 add_test(function test_creation() {
   _("Ensure a simple server can be created.");
   // Explicit callback for this one.
   let server = new StorageServer({
     __proto__: StorageServerCallback,
   });
   do_check_true(!!server);
   server.start(-1, function () {
     _("Started on " + server.port);
     server.stop(run_next_test);
   });
 });
 add_test(function test_synchronous_start() {
   _("Ensure starting using startSynchronous works.");
   let server = new StorageServer();
   server.startSynchronous();
   server.stop(run_next_test);
 });
 add_test(function test_url_parsing() {
   _("Ensure server parses URLs properly.");
   let server = new StorageServer();
   // Check that we can parse a BSO URI.
   let parts = server.pathRE.exec("/2.0/12345/storage/crypto/keys");
   let [all, version, user, first, rest] = parts;
   do_check_eq(all, "/2.0/12345/storage/crypto/keys");
   do_check_eq(version, "2.0");
   do_check_eq(user, "12345");
   do_check_eq(first, "storage");
   do_check_eq(rest, "crypto/keys");
   do_check_eq(null, server.pathRE.exec("/nothing/else"));
   // Check that we can parse a collection URI.
   parts = server.pathRE.exec("/2.0/123/storage/crypto");
   let [all, version, user, first, rest] = parts;
   do_check_eq(all, "/2.0/123/storage/crypto");
   do_check_eq(version, "2.0");
   do_check_eq(user, "123");
   do_check_eq(first, "storage");
   do_check_eq(rest, "crypto");
   // We don't allow trailing slash on storage URI.
   parts = server.pathRE.exec("/2.0/1234/storage/");
   do_check_eq(parts, undefined);
   // storage alone is a valid request.
   parts = server.pathRE.exec("/2.0/123456/storage");
   let [all, version, user, first, rest] = parts;
   do_check_eq(all, "/2.0/123456/storage");
   do_check_eq(version, "2.0");
   do_check_eq(user, "123456");
   do_check_eq(first, "storage");
   do_check_eq(rest, undefined);
   parts = server.storageRE.exec("storage");
   let [all, storage, collection, id] = parts;
   do_check_eq(all, "storage");
   do_check_eq(collection, undefined);
   run_next_test();
 });
 add_test(function test_basic_http() {
   let server = new StorageServer();
   server.registerUser("345", "password");
   do_check_true(server.userExists("345"));
   server.startSynchronous();
   _("Started on " + server.port);
   do_check_eq(server.requestCount, 0);
   let req = localRequest(server, "/2.0/storage/crypto/keys");
   _("req is " + req);
   req.get(function (err) {
     do_check_eq(null, err);
     do_check_eq(server.requestCount, 1);
     server.stop(run_next_test);
   });
 });
 add_test(function test_info_collections() {
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let path = "/2.0/123/info/collections";
   _("info/collections on empty server should be empty object.");
   let request = localRequest(server, path, "123", "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 200);
   do_check_eq(request.response.body, "{}");
   _("Creating an empty collection should result in collection appearing.");
   let coll = server.createCollection("123", "col1");
   let request = localRequest(server, path, "123", "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 200);
   let info = JSON.parse(request.response.body);
   do_check_attribute_count(info, 1);
   do_check_true("col1" in info);
   do_check_eq(info.col1, coll.timestamp);
   server.stop(run_next_test);
 });
 add_test(function test_bso_get_existing() {
   _("Ensure that BSO retrieval works.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     test: {"bso": {"foo": "bar"}}
   });
   server.startSynchronous();
   let coll = server.user("123").collection("test");
   let request = localRequest(server, "/2.0/123/storage/test/bso", "123",
                              "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 200);
   do_check_eq(request.response.headers["content-type"], "application/json");
   let bso = JSON.parse(request.response.body);
   do_check_attribute_count(bso, 3);
   do_check_eq(bso.id, "bso");
   do_check_eq(bso.modified, coll.bso("bso").modified);
   let payload = JSON.parse(bso.payload);
   do_check_attribute_count(payload, 1);
   do_check_eq(payload.foo, "bar");
   server.stop(run_next_test);
 });
 add_test(function test_percent_decoding() {
   _("Ensure query string arguments with percent encoded are handled.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let coll = server.user("123").createCollection("test");
   coll.insert("001", {foo: "bar"});
   coll.insert("002", {bar: "foo"});
   let request = localRequest(server, "/2.0/123/storage/test?ids=001%2C002",
                              "123", "password");
   let error = doGetRequest(request);
   do_check_null(error);
   do_check_eq(request.response.status, 200);
   let items = JSON.parse(request.response.body).items;
   do_check_attribute_count(items, 2);
   server.stop(run_next_test);
 });
 add_test(function test_bso_404() {
   _("Ensure the server responds with a 404 if a BSO does not exist.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     test: {}
   });
   server.startSynchronous();
   let request = localRequest(server, "/2.0/123/storage/test/foo");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 404);
   do_check_false("content-type" in request.response.headers);
   server.stop(run_next_test);
 });
 add_test(function test_bso_if_modified_since_304() {
   _("Ensure the server responds properly to X-If-Modified-Since for BSOs.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     test: {bso: {foo: "bar"}}
   });
   server.startSynchronous();
   let coll = server.user("123").collection("test");
   do_check_neq(coll, null);
   // Rewind clock just in case.
   coll.timestamp -= 10000;
   coll.bso("bso").modified -= 10000;
   let request = localRequest(server, "/2.0/123/storage/test/bso",
                              "123", "password");
   request.setHeader("X-If-Modified-Since", "" + server.serverTime());
   let error = doGetRequest(request);
   do_check_eq(null, error);
   do_check_eq(request.response.status, 304);
   do_check_false("content-type" in request.response.headers);
   let request = localRequest(server, "/2.0/123/storage/test/bso",
                              "123", "password");
   request.setHeader("X-If-Modified-Since", "" + (server.serverTime() - 20000));
   let error = doGetRequest(request);
   do_check_eq(null, error);
   do_check_eq(request.response.status, 200);
   do_check_eq(request.response.headers["content-type"], "application/json");
   server.stop(run_next_test);
 });
 add_test(function test_bso_if_unmodified_since() {
   _("Ensure X-If-Unmodified-Since works properly on BSOs.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     test: {bso: {foo: "bar"}}
   });
   server.startSynchronous();
   let coll = server.user("123").collection("test");
   do_check_neq(coll, null);
   let time = coll.bso("bso").modified;
   _("Ensure we get a 412 for specified times older than server time.");
   let request = localRequest(server, "/2.0/123/storage/test/bso",
                              "123", "password");
   request.setHeader("X-If-Unmodified-Since", time - 5000);
   request.setHeader("Content-Type", "application/json");
   let payload = JSON.stringify({"payload": "foobar"});
   let error = doPutRequest(request, payload);
   do_check_eq(null, error);
   do_check_eq(request.response.status, 412);
   _("Ensure we get a 204 if update goes through.");
   let request = localRequest(server, "/2.0/123/storage/test/bso",
                              "123", "password");
   request.setHeader("Content-Type", "application/json");
   request.setHeader("X-If-Unmodified-Since", time + 1);
   let error = doPutRequest(request, payload);
   do_check_eq(null, error);
   do_check_eq(request.response.status, 204);
   do_check_true(coll.timestamp > time);
   // Not sure why a client would send X-If-Unmodified-Since if a BSO doesn't
   // exist. But, why not test it?
   _("Ensure we get a 201 if creation goes through.");
   let request = localRequest(server, "/2.0/123/storage/test/none",
                              "123", "password");
   request.setHeader("Content-Type", "application/json");
   request.setHeader("X-If-Unmodified-Since", time);
   let error = doPutRequest(request, payload);
   do_check_eq(null, error);
   do_check_eq(request.response.status, 201);
   server.stop(run_next_test);
 });
 add_test(function test_bso_delete_not_exist() {
   _("Ensure server behaves properly when deleting a BSO that does not exist.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.user("123").createCollection("empty");
   server.startSynchronous();
   server.callback.onItemDeleted = function onItemDeleted(username, collection,
                                                          id) {
     do_throw("onItemDeleted should not have been called.");
   };
   let request = localRequest(server, "/2.0/123/storage/empty/nada",
                              "123", "password");
   let error = doDeleteRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 404);
   do_check_false("content-type" in request.response.headers);
   server.stop(run_next_test);
 });
 add_test(function test_bso_delete_exists() {
   _("Ensure proper semantics when deleting a BSO that exists.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let coll = server.user("123").createCollection("test");
   let bso = coll.insert("myid", {foo: "bar"});
   let timestamp = coll.timestamp;
   server.callback.onItemDeleted = function onDeleted(username, collection, id) {
     delete server.callback.onItemDeleted;
     do_check_eq(username, "123");
     do_check_eq(collection, "test");
     do_check_eq(id, "myid");
   };
   let request = localRequest(server, "/2.0/123/storage/test/myid",
                              "123", "password");
   let error = doDeleteRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 204);
   do_check_eq(coll.bsos().length, 0);
   do_check_true(coll.timestamp > timestamp);
   _("On next request the BSO should not exist.");
   let request = localRequest(server, "/2.0/123/storage/test/myid",
                              "123", "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 404);
   server.stop(run_next_test);
 });
 add_test(function test_bso_delete_unmodified() {
   _("Ensure X-If-Unmodified-Since works when deleting BSOs.");
   let server = new StorageServer();
   server.startSynchronous();
   server.registerUser("123", "password");
   let coll = server.user("123").createCollection("test");
   let bso = coll.insert("myid", {foo: "bar"});
   let modified = bso.modified;
   _("Issuing a DELETE with an older time should fail.");
   let path = "/2.0/123/storage/test/myid";
   let request = localRequest(server, path, "123", "password");
   request.setHeader("X-If-Unmodified-Since", modified - 1000);
   let error = doDeleteRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 412);
   do_check_false("content-type" in request.response.headers);
   do_check_neq(coll.bso("myid"), null);
   _("Issuing a DELETE with a newer time should work.");
   let request = localRequest(server, path, "123", "password");
   request.setHeader("X-If-Unmodified-Since", modified + 1000);
   let error = doDeleteRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 204);
   do_check_true(coll.bso("myid").deleted);
   server.stop(run_next_test);
 });
 add_test(function test_collection_get_unmodified_since() {
   _("Ensure conditional unmodified get on collection works when it should.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let collection = server.user("123").createCollection("testcoll");
   collection.insert("bso0", {foo: "bar"});
   let serverModified = collection.timestamp;
   let request1 = localRequest(server, "/2.0/123/storage/testcoll",
                               "123", "password");
   request1.setHeader("X-If-Unmodified-Since", serverModified);
   let error = doGetRequest(request1);
   do_check_null(error);
   do_check_eq(request1.response.status, 200);
   let request2 = localRequest(server, "/2.0/123/storage/testcoll",
                               "123", "password");
   request2.setHeader("X-If-Unmodified-Since", serverModified - 1);
   let error = doGetRequest(request2);
   do_check_null(error);
   do_check_eq(request2.response.status, 412);
   server.stop(run_next_test);
 });
 add_test(function test_bso_get_unmodified_since() {
   _("Ensure conditional unmodified get on BSO works appropriately.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let collection = server.user("123").createCollection("testcoll");
   let bso = collection.insert("bso0", {foo: "bar"});
   let serverModified = bso.modified;
   let request1 = localRequest(server, "/2.0/123/storage/testcoll/bso0",
                               "123", "password");
   request1.setHeader("X-If-Unmodified-Since", serverModified);
   let error = doGetRequest(request1);
   do_check_null(error);
   do_check_eq(request1.response.status, 200);
   let request2 = localRequest(server, "/2.0/123/storage/testcoll/bso0",
                               "123", "password");
   request2.setHeader("X-If-Unmodified-Since", serverModified - 1);
   let error = doGetRequest(request2);
   do_check_null(error);
   do_check_eq(request2.response.status, 412);
   server.stop(run_next_test);
 });
 add_test(function test_missing_collection_404() {
   _("Ensure a missing collection returns a 404.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let request = localRequest(server, "/2.0/123/storage/none", "123", "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 404);
   do_check_false("content-type" in request.response.headers);
   server.stop(run_next_test);
 });
 add_test(function test_get_storage_405() {
   _("Ensure that a GET on /storage results in a 405.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let request = localRequest(server, "/2.0/123/storage", "123", "password");
   let error = doGetRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 405);
   do_check_eq(request.response.headers["allow"], "DELETE");
   server.stop(run_next_test);
 });
 add_test(function test_delete_storage() {
   _("Ensure that deleting all of storage works.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     foo: {a: {foo: "bar"}, b: {bar: "foo"}},
     baz: {c: {bob: "law"}, blah: {law: "blog"}}
   });
   server.startSynchronous();
   let request = localRequest(server, "/2.0/123/storage", "123", "password");
   let error = doDeleteRequest(request);
   do_check_eq(error, null);
   do_check_eq(request.response.status, 204);
   do_check_attribute_count(server.users["123"].collections, 0);
   server.stop(run_next_test);
 });
 add_test(function test_x_num_records() {
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     crypto: {foos: {foo: "bar"},
              bars: {foo: "baz"}}
   });
   server.startSynchronous();
   let bso = localRequest(server, "/2.0/123/storage/crypto/foos");
   bso.get(function (err) {
     // BSO fetches don't have one.
     do_check_false("x-num-records" in this.response.headers);
     let col = localRequest(server, "/2.0/123/storage/crypto");
     col.get(function (err) {
       // Collection fetches do.
       do_check_eq(this.response.headers["x-num-records"], "2");
       server.stop(run_next_test);
     });
   });
 });
 add_test(function test_put_delete_put() {
   _("Bug 790397: Ensure BSO deleted flag is reset on PUT.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.createContents("123", {
     test: {bso: {foo: "bar"}}
   });
   server.startSynchronous();
   _("Ensure we can PUT an existing record.");
   let request1 = localRequest(server, "/2.0/123/storage/test/bso", "123", "password");
   request1.setHeader("Content-Type", "application/json");
   let payload1 = JSON.stringify({"payload": "foobar"});
   let error1 = doPutRequest(request1, payload1);
   do_check_eq(null, error1);
   do_check_eq(request1.response.status, 204);
   _("Ensure we can DELETE it.");
   let request2 = localRequest(server, "/2.0/123/storage/test/bso", "123", "password");
   let error2 = doDeleteRequest(request2);
   do_check_eq(error2, null);
   do_check_eq(request2.response.status, 204);
   do_check_false("content-type" in request2.response.headers);
   _("Ensure we can PUT a previously deleted record.");
   let request3 = localRequest(server, "/2.0/123/storage/test/bso", "123", "password");
   request3.setHeader("Content-Type", "application/json");
   let payload3 = JSON.stringify({"payload": "foobar"});
   let error3 = doPutRequest(request3, payload3);
   do_check_eq(null, error3);
   do_check_eq(request3.response.status, 201);
   _("Ensure we can GET the re-uploaded record.");
   let request4 = localRequest(server, "/2.0/123/storage/test/bso", "123", "password");
   let error4 = doGetRequest(request4);
   do_check_eq(error4, null);
   do_check_eq(request4.response.status, 200);
   do_check_eq(request4.response.headers["content-type"], "application/json");
   server.stop(run_next_test);
 });
 add_test(function test_collection_get_newer() {
   _("Ensure get with newer argument on collection works.");
   let server = new StorageServer();
   server.registerUser("123", "password");
   server.startSynchronous();
   let coll = server.user("123").createCollection("test");
   let bso1 = coll.insert("001", {foo: "bar"});
   let bso2 = coll.insert("002", {bar: "foo"});
   // Don't want both records to have the same timestamp.
   bso2.modified = bso1.modified + 1000;
   function newerRequest(newer) {
     return localRequest(server, "/2.0/123/storage/test?newer=" + newer,
                         "123", "password");
   }
   let request1 = newerRequest(0);
   let error1 = doGetRequest(request1);
   do_check_null(error1);
   do_check_eq(request1.response.status, 200);
   let items1 = JSON.parse(request1.response.body).items;
   do_check_attribute_count(items1, 2);
   let request2 = newerRequest(bso1.modified + 1);
   let error2 = doGetRequest(request2);
   do_check_null(error2);
   do_check_eq(request2.response.status, 200);
   let items2 = JSON.parse(request2.response.body).items;
   do_check_attribute_count(items2, 1);
   let request3 = newerRequest(bso2.modified + 1);
   let error3 = doGetRequest(request3);
   do_check_null(error3);
   do_check_eq(request3.response.status, 200);
   let items3 = JSON.parse(request3.response.body).items;
   do_check_attribute_count(items3, 0);
   server.stop(run_next_test);
 });