The Tor Browser: comparison services/sync/tests/unit/head_http_server.js

comparison: services/sync/tests/unit/head_http_server.js

services/sync/tests/unit/head_http_server.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:58efebc7535f
+const Cm = Components.manager;
+// Shared logging for all HTTP server functions.
+Cu.import("resource://gre/modules/Log.jsm");
+const SYNC_HTTP_LOGGER = "Sync.Test.Server";
+const SYNC_API_VERSION = "1.1";
+// Use the same method that record.js does, which mirrors the server.
+// The server returns timestamps with 1/100 sec granularity. Note that this is
+// subject to change: see Bug 650435.
+function new_timestamp() {
+return Math.round(Date.now() / 10) / 100;
+}
+function return_timestamp(request, response, timestamp) {
+if (!timestamp) {
+timestamp = new_timestamp();
+}
+let body = "" + timestamp;
+response.setHeader("X-Weave-Timestamp", body);
+response.setStatusLine(request.httpVersion, 200, "OK");
+response.bodyOutputStream.write(body, body.length);
+return timestamp;
+}
+function basic_auth_header(user, password) {
+return "Basic " + btoa(user + ":" + Utils.encodeUTF8(password));
+}
+function basic_auth_matches(req, user, password) {
+if (!req.hasHeader("Authorization")) {
+return false;
+}
+let expected = basic_auth_header(user, Utils.encodeUTF8(password));
+return req.getHeader("Authorization") == expected;
+}
+function httpd_basic_auth_handler(body, metadata, response) {
+if (basic_auth_matches(metadata, "guest", "guest")) {
+response.setStatusLine(metadata.httpVersion, 200, "OK, authorized");
+response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
+} else {
+body = "This path exists and is protected - failed";
+response.setStatusLine(metadata.httpVersion, 401, "Unauthorized");
+response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
+}
+response.bodyOutputStream.write(body, body.length);
+}
+/*
+* Represent a WBO on the server
+*/
+function ServerWBO(id, initialPayload, modified) {
+if (!id) {
+throw "No ID for ServerWBO!";
+}
+this.id = id;
+if (!initialPayload) {
+return;
+}
+if (typeof initialPayload == "object") {
+initialPayload = JSON.stringify(initialPayload);
+}
+this.payload = initialPayload;
+this.modified = modified || new_timestamp();
+}
+ServerWBO.prototype = {
+get data() {
+return JSON.parse(this.payload);
+},
+get: function() {
+return JSON.stringify(this, ["id", "modified", "payload"]);
+},
+put: function(input) {
+input = JSON.parse(input);
+this.payload = input.payload;
+this.modified = new_timestamp();
+},
+delete: function() {
+delete this.payload;
+delete this.modified;
+},
+// This handler sets `newModified` on the response body if the collection
+// timestamp has changed. This allows wrapper handlers to extract information
+// that otherwise would exist only in the body stream.
+handler: function() {
+let self = this;
+return function(request, response) {
+var statusCode = 200;
+var status = "OK";
+var body;
+switch(request.method) {
+case "GET":
+if (self.payload) {
+body = self.get();
+} else {
+statusCode = 404;
+status = "Not Found";
+body = "Not Found";
+}
+break;
+case "PUT":
+self.put(readBytesFromInputStream(request.bodyInputStream));
+body = JSON.stringify(self.modified);
+response.setHeader("Content-Type", "application/json");
+response.newModified = self.modified;
+break;
+case "DELETE":
+self.delete();
+let ts = new_timestamp();
+body = JSON.stringify(ts);
+response.setHeader("Content-Type", "application/json");
+response.newModified = ts;
+break;
+}
+response.setHeader("X-Weave-Timestamp", "" + new_timestamp(), false);
+response.setStatusLine(request.httpVersion, statusCode, status);
+response.bodyOutputStream.write(body, body.length);
+};
+}
+};
+/**
+* Represent a collection on the server. The '_wbos' attribute is a
+* mapping of id -> ServerWBO objects.
+*
+* Note that if you want these records to be accessible individually,
+* you need to register their handlers with the server separately, or use a
+* containing HTTP server that will do so on your behalf.
+*
+* @param wbos
+*        An object mapping WBO IDs to ServerWBOs.
+* @param acceptNew
+*        If true, POSTs to this collection URI will result in new WBOs being
+*        created and wired in on the fly.
+* @param timestamp
+*        An optional timestamp value to initialize the modified time of the
+*        collection. This should be in the format returned by new_timestamp().
+*
+* @return the new ServerCollection instance.
+*
+*/
+function ServerCollection(wbos, acceptNew, timestamp) {
+this._wbos = wbos || {};
+this.acceptNew = acceptNew || false;
+/*
+* Track modified timestamp.
+* We can't just use the timestamps of contained WBOs: an empty collection
+* has a modified time.
+*/
+this.timestamp = timestamp || new_timestamp();
+this._log = Log.repository.getLogger(SYNC_HTTP_LOGGER);
+}
+ServerCollection.prototype = {
+/**
+* Convenience accessor for our WBO keys.
+* Excludes deleted items, of course.
+*
+* @param filter
+*        A predicate function (applied to the ID and WBO) which dictates
+*        whether to include the WBO's ID in the output.
+*
+* @return an array of IDs.
+*/
+keys: function keys(filter) {
+return [id for ([id, wbo] in Iterator(this._wbos))
+if (wbo.payload &&
+(!filter || filter(id, wbo)))];
+},
+/**
+* Convenience method to get an array of WBOs.
+* Optionally provide a filter function.
+*
+* @param filter
+*        A predicate function, applied to the WBO, which dictates whether to
+*        include the WBO in the output.
+*
+* @return an array of ServerWBOs.
+*/
+wbos: function wbos(filter) {
+let os = [wbo for ([id, wbo] in Iterator(this._wbos))
+if (wbo.payload)];
+if (filter) {
+return os.filter(filter);
+}
+return os;
+},
+/**
+* Convenience method to get an array of parsed ciphertexts.
+*
+* @return an array of the payloads of each stored WBO.
+*/
+payloads: function () {
+return this.wbos().map(function (wbo) {
+return JSON.parse(JSON.parse(wbo.payload).ciphertext);
+});
+},
+// Just for syntactic elegance.
+wbo: function wbo(id) {
+return this._wbos[id];
+},
+payload: function payload(id) {
+return this.wbo(id).payload;
+},
+/**
+* Insert the provided WBO under its ID.
+*
+* @return the provided WBO.
+*/
+insertWBO: function insertWBO(wbo) {
+return this._wbos[wbo.id] = wbo;
+},
+/**
+* Insert the provided payload as part of a new ServerWBO with the provided
+* ID.
+*
+* @param id
+*        The GUID for the WBO.
+* @param payload
+*        The payload, as provided to the ServerWBO constructor.
+* @param modified
+*        An optional modified time for the ServerWBO.
+*
+* @return the inserted WBO.
+*/
+insert: function insert(id, payload, modified) {
+return this.insertWBO(new ServerWBO(id, payload, modified));
+},
+/**
+* Removes an object entirely from the collection.
+*
+* @param id
+*        (string) ID to remove.
+*/
+remove: function remove(id) {
+delete this._wbos[id];
+},
+_inResultSet: function(wbo, options) {
+return wbo.payload
+&& (!options.ids || (options.ids.indexOf(wbo.id) != -1))
+&& (!options.newer || (wbo.modified > options.newer));
+},
+count: function(options) {
+options = options || {};
+let c = 0;
+for (let [id, wbo] in Iterator(this._wbos)) {
+if (wbo.modified && this._inResultSet(wbo, options)) {
+c++;
+}
+}
+return c;
+},
+get: function(options) {
+let result;
+if (options.full) {
+let data = [wbo.get() for ([id, wbo] in Iterator(this._wbos))
+// Drop deleted.
+if (wbo.modified &&
+this._inResultSet(wbo, options))];
+if (options.limit) {
+data = data.slice(0, options.limit);
+}
+// Our implementation of application/newlines.
+result = data.join("\n") + "\n";
+// Use options as a backchannel to report count.
+options.recordCount = data.length;
+} else {
+let data = [id for ([id, wbo] in Iterator(this._wbos))
+if (this._inResultSet(wbo, options))];
+if (options.limit) {
+data = data.slice(0, options.limit);
+}
+result = JSON.stringify(data);
+options.recordCount = data.length;
+}
+return result;
+},
+post: function(input) {
+input = JSON.parse(input);
+let success = [];
+let failed = {};
+// This will count records where we have an existing ServerWBO
+// registered with us as successful and all other records as failed.
+for each (let record in input) {
+let wbo = this.wbo(record.id);
+if (!wbo && this.acceptNew) {
+this._log.debug("Creating WBO " + JSON.stringify(record.id) +
+" on the fly.");
+wbo = new ServerWBO(record.id);
+this.insertWBO(wbo);
+}
+if (wbo) {
+wbo.payload = record.payload;
+wbo.modified = new_timestamp();
+success.push(record.id);
+} else {
+failed[record.id] = "no wbo configured";
+}
+}
+return {modified: new_timestamp(),
+success: success,
+failed: failed};
+},
+delete: function(options) {
+let deleted = [];
+for (let [id, wbo] in Iterator(this._wbos)) {
+if (this._inResultSet(wbo, options)) {
+this._log.debug("Deleting " + JSON.stringify(wbo));
+deleted.push(wbo.id);
+wbo.delete();
+}
+}
+return deleted;
+},
+// This handler sets `newModified` on the response body if the collection
+// timestamp has changed.
+handler: function() {
+let self = this;
+return function(request, response) {
+var statusCode = 200;
+var status = "OK";
+var body;
+// Parse queryString
+let options = {};
+for each (let chunk in request.queryString.split("&")) {
+if (!chunk) {
+continue;
+}
+chunk = chunk.split("=");
+if (chunk.length == 1) {
+options[chunk[0]] = "";
+} else {
+options[chunk[0]] = chunk[1];
+}
+}
+if (options.ids) {
+options.ids = options.ids.split(",");
+}
+if (options.newer) {
+options.newer = parseFloat(options.newer);
+}
+if (options.limit) {
+options.limit = parseInt(options.limit, 10);
+}
+switch(request.method) {
+case "GET":
+body = self.get(options);
+// "If supported by the db, this header will return the number of
+// records total in the request body of any multiple-record GET
+// request."
+let records = options.recordCount;
+self._log.info("Records: " + records);
+if (records != null) {
+response.setHeader("X-Weave-Records", "" + records);
+}
+break;
+case "POST":
+let res = self.post(readBytesFromInputStream(request.bodyInputStream));
+body = JSON.stringify(res);
+response.newModified = res.modified;
+break;
+case "DELETE":
+self._log.debug("Invoking ServerCollection.DELETE.");
+let deleted = self.delete(options);
+let ts = new_timestamp();
+body = JSON.stringify(ts);
+response.newModified = ts;
+response.deleted = deleted;
+break;
+}
+response.setHeader("X-Weave-Timestamp",
+"" + new_timestamp(),
+false);
+response.setStatusLine(request.httpVersion, statusCode, status);
+response.bodyOutputStream.write(body, body.length);
+// Update the collection timestamp to the appropriate modified time.
+// This is either a value set by the handler, or the current time.
+if (request.method != "GET") {
+this.timestamp = (response.newModified >= 0) ?
+response.newModified :
+new_timestamp();
+}
+};
+}
+};
+/*
+* Test setup helpers.
+*/
+function sync_httpd_setup(handlers) {
+handlers["/1.1/foo/storage/meta/global"]
+= (new ServerWBO("global", {})).handler();
+return httpd_setup(handlers);
+}
+/*
+* Track collection modified times. Return closures.
+*/
+function track_collections_helper() {
+/*
+* Our tracking object.
+*/
+let collections = {};
+/*
+* Update the timestamp of a collection.
+*/
+function update_collection(coll, ts) {
+_("Updating collection " + coll + " to " + ts);
+let timestamp = ts || new_timestamp();
+collections[coll] = timestamp;
+}
+/*
+* Invoke a handler, updating the collection's modified timestamp unless
+* it's a GET request.
+*/
+function with_updated_collection(coll, f) {
+return function(request, response) {
+f.call(this, request, response);
+// Update the collection timestamp to the appropriate modified time.
+// This is either a value set by the handler, or the current time.
+if (request.method != "GET") {
+update_collection(coll, response.newModified)
+}
+};
+}
+/*
+* Return the info/collections object.
+*/
+function info_collections(request, response) {
+let body = "Error.";
+switch(request.method) {
+case "GET":
+body = JSON.stringify(collections);
+break;
+default:
+throw "Non-GET on info_collections.";
+}
+response.setHeader("Content-Type", "application/json");
+response.setHeader("X-Weave-Timestamp",
+"" + new_timestamp(),
+false);
+response.setStatusLine(request.httpVersion, 200, "OK");
+response.bodyOutputStream.write(body, body.length);
+}
+return {"collections": collections,
+"handler": info_collections,
+"with_updated_collection": with_updated_collection,
+"update_collection": update_collection};
+}
+//===========================================================================//
+// httpd.js-based Sync server.                                               //
+//===========================================================================//
+/**
+* In general, the preferred way of using SyncServer is to directly introspect
+* it. Callbacks are available for operations which are hard to verify through
+* introspection, such as deletions.
+*
+* One of the goals of this server is to provide enough hooks for test code to
+* find out what it needs without monkeypatching. Use this object as your
+* prototype, and override as appropriate.
+*/
+let SyncServerCallback = {
+onCollectionDeleted: function onCollectionDeleted(user, collection) {},
+onItemDeleted: function onItemDeleted(user, collection, wboID) {},
+/**
+* Called at the top of every request.
+*
+* Allows the test to inspect the request. Hooks should be careful not to
+* modify or change state of the request or they may impact future processing.
+*/
+onRequest: function onRequest(request) {},
+};
+/**
+* Construct a new test Sync server. Takes a callback object (e.g.,
+* SyncServerCallback) as input.
+*/
+function SyncServer(callback) {
+this.callback = callback || {__proto__: SyncServerCallback};
+this.server   = new HttpServer();
+this.started  = false;
+this.users    = {};
+this._log     = Log.repository.getLogger(SYNC_HTTP_LOGGER);
+// Install our own default handler. This allows us to mess around with the
+// whole URL space.
+let handler = this.server._handler;
+handler._handleDefault = this.handleDefault.bind(this, handler);
+}
+SyncServer.prototype = {
+server: null,    // HttpServer.
+users:  null,    // Map of username => {collections, password}.
+/**
+* Start the SyncServer's underlying HTTP server.
+*
+* @param port
+*        The numeric port on which to start. A falsy value implies the
+*        default, a randomly chosen port.
+* @param cb
+*        A callback function (of no arguments) which is invoked after
+*        startup.
+*/
+start: function start(port, cb) {
+if (this.started) {
+this._log.warn("Warning: server already started on " + this.port);
+return;
+}
+try {
+this.server.start(port);
+let i = this.server.identity;
+this.port = i.primaryPort;
+this.baseURI = i.primaryScheme + "://" + i.primaryHost + ":" +
+i.primaryPort + "/";
+this.started = true;
+if (cb) {
+cb();
+}
+} catch (ex) {
+_("==========================================");
+_("Got exception starting Sync HTTP server.");
+_("Error: " + Utils.exceptionStr(ex));
+_("Is there a process already listening on port " + port + "?");
+_("==========================================");
+do_throw(ex);
+}
+},
+/**
+* Stop the SyncServer's HTTP server.
+*
+* @param cb
+*        A callback function. Invoked after the server has been stopped.
+*
+*/
+stop: function stop(cb) {
+if (!this.started) {
+this._log.warn("SyncServer: Warning: server not running. Can't stop me now!");
+return;
+}
+this.server.stop(cb);
+this.started = false;
+},
+/**
+* Return a server timestamp for a record.
+* The server returns timestamps with 1/100 sec granularity. Note that this is
+* subject to change: see Bug 650435.
+*/
+timestamp: function timestamp() {
+return new_timestamp();
+},
+/**
+* Create a new user, complete with an empty set of collections.
+*
+* @param username
+*        The username to use. An Error will be thrown if a user by that name
+*        already exists.
+* @param password
+*        A password string.
+*
+* @return a user object, as would be returned by server.user(username).
+*/
+registerUser: function registerUser(username, password) {
+if (username in this.users) {
+throw new Error("User already exists.");
+}
+this.users[username] = {
+password: password,
+collections: {}
+};
+return this.user(username);
+},
+userExists: function userExists(username) {
+return username in this.users;
+},
+getCollection: function getCollection(username, collection) {
+return this.users[username].collections[collection];
+},
+_insertCollection: function _insertCollection(collections, collection, wbos) {
+let coll = new ServerCollection(wbos, true);
+coll.collectionHandler = coll.handler();
+collections[collection] = coll;
+return coll;
+},
+createCollection: function createCollection(username, collection, wbos) {
+if (!(username in this.users)) {
+throw new Error("Unknown user.");
+}
+let collections = this.users[username].collections;
+if (collection in collections) {
+throw new Error("Collection already exists.");
+}
+return this._insertCollection(collections, collection, wbos);
+},
+/**
+* Accept a map like the following:
+* {
+*   meta: {global: {version: 1, ...}},
+*   crypto: {"keys": {}, foo: {bar: 2}},
+*   bookmarks: {}
+* }
+* to cause collections and WBOs to be created.
+* If a collection already exists, no error is raised.
+* If a WBO already exists, it will be updated to the new contents.
+*/
+createContents: function createContents(username, collections) {
+if (!(username in this.users)) {
+throw new Error("Unknown user.");
+}
+let userCollections = this.users[username].collections;
+for (let [id, contents] in Iterator(collections)) {
+let coll = userCollections[id] ||
+this._insertCollection(userCollections, id);
+for (let [wboID, payload] in Iterator(contents)) {
+coll.insert(wboID, payload);
+}
+}
+},
+/**
+* Insert a WBO in an existing collection.
+*/
+insertWBO: function insertWBO(username, collection, wbo) {
+if (!(username in this.users)) {
+throw new Error("Unknown user.");
+}
+let userCollections = this.users[username].collections;
+if (!(collection in userCollections)) {
+throw new Error("Unknown collection.");
+}
+userCollections[collection].insertWBO(wbo);
+return wbo;
+},
+/**
+* Delete all of the collections for the named user.
+*
+* @param username
+*        The name of the affected user.
+*
+* @return a timestamp.
+*/
+deleteCollections: function deleteCollections(username) {
+if (!(username in this.users)) {
+throw new Error("Unknown user.");
+}
+let userCollections = this.users[username].collections;
+for each (let [name, coll] in Iterator(userCollections)) {
+this._log.trace("Bulk deleting " + name + " for " + username + "...");
+coll.delete({});
+}
+this.users[username].collections = {};
+return this.timestamp();
+},
+/**
+* Simple accessor to allow collective binding and abbreviation of a bunch of
+* methods. Yay!
+* Use like this:
+*
+*   let u = server.user("john");
+*   u.collection("bookmarks").wbo("abcdefg").payload;  // Etc.
+*
+* @return a proxy for the user data stored in this server.
+*/
+user: function user(username) {
+let collection       = this.getCollection.bind(this, username);
+let createCollection = this.createCollection.bind(this, username);
+let createContents   = this.createContents.bind(this, username);
+let modified         = function (collectionName) {
+return collection(collectionName).timestamp;
+}
+let deleteCollections = this.deleteCollections.bind(this, username);
+return {
+collection:        collection,
+createCollection:  createCollection,
+createContents:    createContents,
+deleteCollections: deleteCollections,
+modified:          modified
+};
+},
+/*
+* Regular expressions for splitting up Sync request paths.
+* Sync URLs are of the form:
+*   /$apipath/$version/$user/$further
+* where $further is usually:
+*   storage/$collection/$wbo
+* or
+*   storage/$collection
+* or
+*   info/$op
+* We assume for the sake of simplicity that $apipath is empty.
+*
+* N.B., we don't follow any kind of username spec here, because as far as I
+* can tell there isn't one. See Bug 689671. Instead we follow the Python
+* server code.
+*
+* Path: [all, version, username, first, rest]
+* Storage: [all, collection?, id?]
+*/
+pathRE: /^\/([0-9]+(?:\.[0-9]+)?)\/([-._a-zA-Z0-9]+)(?:\/([^\/]+)(?:\/(.+))?)?$/,
+storageRE: /^([-_a-zA-Z0-9]+)(?:\/([-_a-zA-Z0-9]+)\/?)?$/,
+defaultHeaders: {},
+/**
+* HTTP response utility.
+*/
+respond: function respond(req, resp, code, status, body, headers) {
+resp.setStatusLine(req.httpVersion, code, status);
+for each (let [header, value] in Iterator(headers || this.defaultHeaders)) {
+resp.setHeader(header, value);
+}
+resp.setHeader("X-Weave-Timestamp", "" + this.timestamp(), false);
+resp.bodyOutputStream.write(body, body.length);
+},
+/**
+* This is invoked by the HttpServer. `this` is bound to the SyncServer;
+* `handler` is the HttpServer's handler.
+*
+* TODO: need to use the correct Sync API response codes and errors here.
+* TODO: Basic Auth.
+* TODO: check username in path against username in BasicAuth.
+*/
+handleDefault: function handleDefault(handler, req, resp) {
+try {
+this._handleDefault(handler, req, resp);
+} catch (e) {
+if (e instanceof HttpError) {
+this.respond(req, resp, e.code, e.description, "", {});
+} else {
+throw e;
+}
+}
+},
+_handleDefault: function _handleDefault(handler, req, resp) {
+this._log.debug("SyncServer: Handling request: " + req.method + " " + req.path);
+if (this.callback.onRequest) {
+this.callback.onRequest(req);
+}
+let parts = this.pathRE.exec(req.path);
+if (!parts) {
+this._log.debug("SyncServer: Unexpected request: bad URL " + req.path);
+throw HTTP_404;
+}
+let [all, version, username, first, rest] = parts;
+// Doing a float compare of the version allows for us to pretend there was
+// a node-reassignment - eg, we could re-assign from "1.1/user/" to
+// "1.10/user" - this server will then still accept requests with the new
+// URL while any code in sync itself which compares URLs will see a
+// different URL.
+if (parseFloat(version) != parseFloat(SYNC_API_VERSION)) {
+this._log.debug("SyncServer: Unknown version.");
+throw HTTP_404;
+}
+if (!this.userExists(username)) {
+this._log.debug("SyncServer: Unknown user.");
+throw HTTP_401;
+}
+// Hand off to the appropriate handler for this path component.
+if (first in this.toplevelHandlers) {
+let handler = this.toplevelHandlers[first];
+return handler.call(this, handler, req, resp, version, username, rest);
+}
+this._log.debug("SyncServer: Unknown top-level " + first);
+throw HTTP_404;
+},
+/**
+* Compute the object that is returned for an info/collections request.
+*/
+infoCollections: function infoCollections(username) {
+let responseObject = {};
+let colls = this.users[username].collections;
+for (let coll in colls) {
+responseObject[coll] = colls[coll].timestamp;
+}
+this._log.trace("SyncServer: info/collections returning " +
+JSON.stringify(responseObject));
+return responseObject;
+},
+/**
+* Collection of the handler methods we use for top-level path components.
+*/
+toplevelHandlers: {
+"storage": function handleStorage(handler, req, resp, version, username, rest) {
+let respond = this.respond.bind(this, req, resp);
+if (!rest || !rest.length) {
+this._log.debug("SyncServer: top-level storage " +
+req.method + " request.");
+// TODO: verify if this is spec-compliant.
+if (req.method != "DELETE") {
+respond(405, "Method Not Allowed", "[]", {"Allow": "DELETE"});
+return undefined;
+}
+// Delete all collections and track the timestamp for the response.
+let timestamp = this.user(username).deleteCollections();
+// Return timestamp and OK for deletion.
+respond(200, "OK", JSON.stringify(timestamp));
+return undefined;
+}
+let match = this.storageRE.exec(rest);
+if (!match) {
+this._log.warn("SyncServer: Unknown storage operation " + rest);
+throw HTTP_404;
+}
+let [all, collection, wboID] = match;
+let coll = this.getCollection(username, collection);
+switch (req.method) {
+case "GET":
+if (!coll) {
+if (wboID) {
+respond(404, "Not found", "Not found");
+return undefined;
+}
+// *cries inside*: Bug 687299.
+respond(200, "OK", "[]");
+return undefined;
+}
+if (!wboID) {
+return coll.collectionHandler(req, resp);
+}
+let wbo = coll.wbo(wboID);
+if (!wbo) {
+respond(404, "Not found", "Not found");
+return undefined;
+}
+return wbo.handler()(req, resp);
+// TODO: implement handling of X-If-Unmodified-Since for write verbs.
+case "DELETE":
+if (!coll) {
+respond(200, "OK", "{}");
+return undefined;
+}
+if (wboID) {
+let wbo = coll.wbo(wboID);
+if (wbo) {
+wbo.delete();
+this.callback.onItemDeleted(username, collection, wboID);
+}
+respond(200, "OK", "{}");
+return undefined;
+}
+coll.collectionHandler(req, resp);
+// Spot if this is a DELETE for some IDs, and don't blow away the
+// whole collection!
+//
+// We already handled deleting the WBOs by invoking the deleted
+// collection's handler. However, in the case of
+//
+//   DELETE storage/foobar
+//
+// we also need to remove foobar from the collections map. This
+// clause tries to differentiate the above request from
+//
+//  DELETE storage/foobar?ids=foo,baz
+//
+// and do the right thing.
+// TODO: less hacky method.
+if (-1 == req.queryString.indexOf("ids=")) {
+// When you delete the entire collection, we drop it.
+this._log.debug("Deleting entire collection.");
+delete this.users[username].collections[collection];
+this.callback.onCollectionDeleted(username, collection);
+}
+// Notify of item deletion.
+let deleted = resp.deleted || [];
+for (let i = 0; i < deleted.length; ++i) {
+this.callback.onItemDeleted(username, collection, deleted[i]);
+}
+return undefined;
+case "POST":
+case "PUT":
+if (!coll) {
+coll = this.createCollection(username, collection);
+}
+if (wboID) {
+let wbo = coll.wbo(wboID);
+if (!wbo) {
+this._log.trace("SyncServer: creating WBO " + collection + "/" + wboID);
+wbo = coll.insert(wboID);
+}
+// Rather than instantiate each WBO's handler function, do it once
+// per request. They get hit far less often than do collections.
+wbo.handler()(req, resp);
+coll.timestamp = resp.newModified;
+return resp;
+}
+return coll.collectionHandler(req, resp);
+default:
+throw "Request method " + req.method + " not implemented.";
+}
+},
+"info": function handleInfo(handler, req, resp, version, username, rest) {
+switch (rest) {
+case "collections":
+let body = JSON.stringify(this.infoCollections(username));
+this.respond(req, resp, 200, "OK", body, {
+"Content-Type": "application/json"
+});
+return;
+case "collection_usage":
+case "collection_counts":
+case "quota":
+// TODO: implement additional info methods.
+this.respond(req, resp, 200, "OK", "TODO");
+return;
+default:
+// TODO
+this._log.warn("SyncServer: Unknown info operation " + rest);
+throw HTTP_404;
+}
+}
+}
+};
+/**
+* Test helper.
+*/
+function serverForUsers(users, contents, callback) {
+let server = new SyncServer(callback);
+for (let [user, pass] in Iterator(users)) {
+server.registerUser(user, pass);
+server.createContents(user, contents);
+}
+server.start();
+return server;
+}