diff -r 000000000000 -r 6474c204b198 services/sync/tests/unit/test_clients_engine.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/services/sync/tests/unit/test_clients_engine.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,584 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+Cu.import("resource://services-sync/constants.js");
+Cu.import("resource://services-sync/engines.js");
+Cu.import("resource://services-sync/engines/clients.js");
+Cu.import("resource://services-sync/record.js");
+Cu.import("resource://services-sync/service.js");
+Cu.import("resource://services-sync/util.js");
+Cu.import("resource://testing-common/services/sync/utils.js");
+
+const MORE_THAN_CLIENTS_TTL_REFRESH = 691200; // 8 days
+const LESS_THAN_CLIENTS_TTL_REFRESH = 86400;  // 1 day
+
+let engine = Service.clientsEngine;
+
+/**
+ * Unpack the record with this ID, and verify that it has the same version that
+ * we should be putting into records.
+ */
+function check_record_version(user, id) {
+    let payload = JSON.parse(user.collection("clients").wbo(id).payload);
+
+    let rec = new CryptoWrapper();
+    rec.id = id;
+    rec.collection = "clients";
+    rec.ciphertext = payload.ciphertext;
+    rec.hmac = payload.hmac;
+    rec.IV = payload.IV;
+
+    let cleartext = rec.decrypt(Service.collectionKeys.keyForCollection("clients"));
+
+    _("Payload is " + JSON.stringify(cleartext));
+    do_check_eq(Services.appinfo.version, cleartext.version);
+    do_check_eq(2, cleartext.protocols.length);
+    do_check_eq("1.1", cleartext.protocols[0]);
+    do_check_eq("1.5", cleartext.protocols[1]);
+}
+
+add_test(function test_bad_hmac() {
+  _("Ensure that Clients engine deletes corrupt records.");
+  let contents = {
+    meta: {global: {engines: {clients: {version: engine.version,
+                                        syncID: engine.syncID}}}},
+    clients: {},
+    crypto: {}
+  };
+  let deletedCollections = [];
+  let deletedItems       = [];
+  let callback = {
+    __proto__: SyncServerCallback,
+    onItemDeleted: function (username, coll, wboID) {
+      deletedItems.push(coll + "/" + wboID);
+    },
+    onCollectionDeleted: function (username, coll) {
+      deletedCollections.push(coll);
+    }
+  }
+  let server = serverForUsers({"foo": "password"}, contents, callback);
+  let user   = server.user("foo");
+
+  function check_clients_count(expectedCount) {
+    let stack = Components.stack.caller;
+    let coll  = user.collection("clients");
+
+    // Treat a non-existent collection as empty.
+    do_check_eq(expectedCount, coll ? coll.count() : 0, stack);
+  }
+
+  function check_client_deleted(id) {
+    let coll = user.collection("clients");
+    let wbo  = coll.wbo(id);
+    return !wbo || !wbo.payload;
+  }
+
+  function uploadNewKeys() {
+    generateNewKeys(Service.collectionKeys);
+    let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
+    serverKeys.encrypt(Service.identity.syncKeyBundle);
+    do_check_true(serverKeys.upload(Service.resource(Service.cryptoKeysURL)).success);
+  }
+
+  try {
+    ensureLegacyIdentityManager();
+    let passphrase     = "abcdeabcdeabcdeabcdeabcdea";
+    Service.serverURL  = server.baseURI;
+    Service.login("foo", "ilovejane", passphrase);
+
+    generateNewKeys(Service.collectionKeys);
+
+    _("First sync, client record is uploaded");
+    do_check_eq(engine.lastRecordUpload, 0);
+    check_clients_count(0);
+    engine._sync();
+    check_clients_count(1);
+    do_check_true(engine.lastRecordUpload > 0);
+
+    // Our uploaded record has a version.
+    check_record_version(user, engine.localID);
+
+    // Initial setup can wipe the server, so clean up.
+    deletedCollections = [];
+    deletedItems       = [];
+
+    _("Change our keys and our client ID, reupload keys.");
+    let oldLocalID  = engine.localID;     // Preserve to test for deletion!
+    engine.localID = Utils.makeGUID();
+    engine.resetClient();
+    generateNewKeys(Service.collectionKeys);
+    let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
+    serverKeys.encrypt(Service.identity.syncKeyBundle);
+    do_check_true(serverKeys.upload(Service.resource(Service.cryptoKeysURL)).success);
+
+    _("Sync.");
+    engine._sync();
+
+    _("Old record " + oldLocalID + " was deleted, new one uploaded.");
+    check_clients_count(1);
+    check_client_deleted(oldLocalID);
+
+    _("Now change our keys but don't upload them. " +
+      "That means we get an HMAC error but redownload keys.");
+    Service.lastHMACEvent = 0;
+    engine.localID = Utils.makeGUID();
+    engine.resetClient();
+    generateNewKeys(Service.collectionKeys);
+    deletedCollections = [];
+    deletedItems       = [];
+    check_clients_count(1);
+    engine._sync();
+
+    _("Old record was not deleted, new one uploaded.");
+    do_check_eq(deletedCollections.length, 0);
+    do_check_eq(deletedItems.length, 0);
+    check_clients_count(2);
+
+    _("Now try the scenario where our keys are wrong *and* there's a bad record.");
+    // Clean up and start fresh.
+    user.collection("clients")._wbos = {};
+    Service.lastHMACEvent = 0;
+    engine.localID = Utils.makeGUID();
+    engine.resetClient();
+    deletedCollections = [];
+    deletedItems       = [];
+    check_clients_count(0);
+
+    uploadNewKeys();
+
+    // Sync once to upload a record.
+    engine._sync();
+    check_clients_count(1);
+
+    // Generate and upload new keys, so the old client record is wrong.
+    uploadNewKeys();
+
+    // Create a new client record and new keys. Now our keys are wrong, as well
+    // as the object on the server. We'll download the new keys and also delete
+    // the bad client record.
+    oldLocalID  = engine.localID;         // Preserve to test for deletion!
+    engine.localID = Utils.makeGUID();
+    engine.resetClient();
+    generateNewKeys(Service.collectionKeys);
+    let oldKey = Service.collectionKeys.keyForCollection();
+
+    do_check_eq(deletedCollections.length, 0);
+    do_check_eq(deletedItems.length, 0);
+    engine._sync();
+    do_check_eq(deletedItems.length, 1);
+    check_client_deleted(oldLocalID);
+    check_clients_count(1);
+    let newKey = Service.collectionKeys.keyForCollection();
+    do_check_false(oldKey.equals(newKey));
+
+  } finally {
+    Svc.Prefs.resetBranch("");
+    Service.recordManager.clearCache();
+    server.stop(run_next_test);
+  }
+});
+
+add_test(function test_properties() {
+  _("Test lastRecordUpload property");
+  try {
+    do_check_eq(Svc.Prefs.get("clients.lastRecordUpload"), undefined);
+    do_check_eq(engine.lastRecordUpload, 0);
+
+    let now = Date.now();
+    engine.lastRecordUpload = now / 1000;
+    do_check_eq(engine.lastRecordUpload, Math.floor(now / 1000));
+  } finally {
+    Svc.Prefs.resetBranch("");
+    run_next_test();
+  }
+});
+
+add_test(function test_sync() {
+  _("Ensure that Clients engine uploads a new client record once a week.");
+
+  let contents = {
+    meta: {global: {engines: {clients: {version: engine.version,
+                                        syncID: engine.syncID}}}},
+    clients: {},
+    crypto: {}
+  };
+  let server = serverForUsers({"foo": "password"}, contents);
+  let user   = server.user("foo");
+
+  new SyncTestingInfrastructure(server.server);
+  generateNewKeys(Service.collectionKeys);
+
+  function clientWBO() {
+    return user.collection("clients").wbo(engine.localID);
+  }
+
+  try {
+
+    _("First sync. Client record is uploaded.");
+    do_check_eq(clientWBO(), undefined);
+    do_check_eq(engine.lastRecordUpload, 0);
+    engine._sync();
+    do_check_true(!!clientWBO().payload);
+    do_check_true(engine.lastRecordUpload > 0);
+
+    _("Let's time travel more than a week back, new record should've been uploaded.");
+    engine.lastRecordUpload -= MORE_THAN_CLIENTS_TTL_REFRESH;
+    let lastweek = engine.lastRecordUpload;
+    clientWBO().payload = undefined;
+    engine._sync();
+    do_check_true(!!clientWBO().payload);
+    do_check_true(engine.lastRecordUpload > lastweek);
+
+    _("Remove client record.");
+    engine.removeClientData();
+    do_check_eq(clientWBO().payload, undefined);
+
+    _("Time travel one day back, no record uploaded.");
+    engine.lastRecordUpload -= LESS_THAN_CLIENTS_TTL_REFRESH;
+    let yesterday = engine.lastRecordUpload;
+    engine._sync();
+    do_check_eq(clientWBO().payload, undefined);
+    do_check_eq(engine.lastRecordUpload, yesterday);
+
+  } finally {
+    Svc.Prefs.resetBranch("");
+    Service.recordManager.clearCache();
+    server.stop(run_next_test);
+  }
+});
+
+add_test(function test_client_name_change() {
+  _("Ensure client name change incurs a client record update.");
+
+  let tracker = engine._tracker;
+
+  let localID = engine.localID;
+  let initialName = engine.localName;
+
+  Svc.Obs.notify("weave:engine:start-tracking");
+  _("initial name: " + initialName);
+
+  // Tracker already has data, so clear it.
+  tracker.clearChangedIDs();
+
+  let initialScore = tracker.score;
+
+  do_check_eq(Object.keys(tracker.changedIDs).length, 0);
+
+  Svc.Prefs.set("client.name", "new name");
+
+  _("new name: " + engine.localName);
+  do_check_neq(initialName, engine.localName);
+  do_check_eq(Object.keys(tracker.changedIDs).length, 1);
+  do_check_true(engine.localID in tracker.changedIDs);
+  do_check_true(tracker.score > initialScore);
+  do_check_true(tracker.score >= SCORE_INCREMENT_XLARGE);
+
+  Svc.Obs.notify("weave:engine:stop-tracking");
+
+  run_next_test();
+});
+
+add_test(function test_send_command() {
+  _("Verifies _sendCommandToClient puts commands in the outbound queue.");
+
+  let store = engine._store;
+  let tracker = engine._tracker;
+  let remoteId = Utils.makeGUID();
+  let rec = new ClientsRec("clients", remoteId);
+
+  store.create(rec);
+  let remoteRecord = store.createRecord(remoteId, "clients");
+
+  let action = "testCommand";
+  let args = ["foo", "bar"];
+
+  engine._sendCommandToClient(action, args, remoteId);
+
+  let newRecord = store._remoteClients[remoteId];
+  do_check_neq(newRecord, undefined);
+  do_check_eq(newRecord.commands.length, 1);
+
+  let command = newRecord.commands[0];
+  do_check_eq(command.command, action);
+  do_check_eq(command.args.length, 2);
+  do_check_eq(command.args, args);
+
+  do_check_neq(tracker.changedIDs[remoteId], undefined);
+
+  run_next_test();
+});
+
+add_test(function test_command_validation() {
+  _("Verifies that command validation works properly.");
+
+  let store = engine._store;
+
+  let testCommands = [
+    ["resetAll",    [],       true ],
+    ["resetAll",    ["foo"],  false],
+    ["resetEngine", ["tabs"], true ],
+    ["resetEngine", [],       false],
+    ["wipeAll",     [],       true ],
+    ["wipeAll",     ["foo"],  false],
+    ["wipeEngine",  ["tabs"], true ],
+    ["wipeEngine",  [],       false],
+    ["logout",      [],       true ],
+    ["logout",      ["foo"],  false],
+    ["__UNKNOWN__", [],       false]
+  ];
+
+  for each (let [action, args, expectedResult] in testCommands) {
+    let remoteId = Utils.makeGUID();
+    let rec = new ClientsRec("clients", remoteId);
+
+    store.create(rec);
+    store.createRecord(remoteId, "clients");
+
+    engine.sendCommand(action, args, remoteId);
+
+    let newRecord = store._remoteClients[remoteId];
+    do_check_neq(newRecord, undefined);
+
+    if (expectedResult) {
+      _("Ensuring command is sent: " + action);
+      do_check_eq(newRecord.commands.length, 1);
+
+      let command = newRecord.commands[0];
+      do_check_eq(command.command, action);
+      do_check_eq(command.args, args);
+
+      do_check_neq(engine._tracker, undefined);
+      do_check_neq(engine._tracker.changedIDs[remoteId], undefined);
+    } else {
+      _("Ensuring command is scrubbed: " + action);
+      do_check_eq(newRecord.commands, undefined);
+
+      if (store._tracker) {
+        do_check_eq(engine._tracker[remoteId], undefined);
+      }
+    }
+
+  }
+  run_next_test();
+});
+
+add_test(function test_command_duplication() {
+  _("Ensures duplicate commands are detected and not added");
+
+  let store = engine._store;
+  let remoteId = Utils.makeGUID();
+  let rec = new ClientsRec("clients", remoteId);
+  store.create(rec);
+  store.createRecord(remoteId, "clients");
+
+  let action = "resetAll";
+  let args = [];
+
+  engine.sendCommand(action, args, remoteId);
+  engine.sendCommand(action, args, remoteId);
+
+  let newRecord = store._remoteClients[remoteId];
+  do_check_eq(newRecord.commands.length, 1);
+
+  _("Check variant args length");
+  newRecord.commands = [];
+
+  action = "resetEngine";
+  engine.sendCommand(action, [{ x: "foo" }], remoteId);
+  engine.sendCommand(action, [{ x: "bar" }], remoteId);
+
+  _("Make sure we spot a real dupe argument.");
+  engine.sendCommand(action, [{ x: "bar" }], remoteId);
+
+  do_check_eq(newRecord.commands.length, 2);
+
+  run_next_test();
+});
+
+add_test(function test_command_invalid_client() {
+  _("Ensures invalid client IDs are caught");
+
+  let id = Utils.makeGUID();
+  let error;
+
+  try {
+    engine.sendCommand("wipeAll", [], id);
+  } catch (ex) {
+    error = ex;
+  }
+
+  do_check_eq(error.message.indexOf("Unknown remote client ID: "), 0);
+
+  run_next_test();
+});
+
+add_test(function test_process_incoming_commands() {
+  _("Ensures local commands are executed");
+
+  engine.localCommands = [{ command: "logout", args: [] }];
+
+  let ev = "weave:service:logout:finish";
+
+  var handler = function() {
+    Svc.Obs.remove(ev, handler);
+    run_next_test();
+  };
+
+  Svc.Obs.add(ev, handler);
+
+  // logout command causes processIncomingCommands to return explicit false.
+  do_check_false(engine.processIncomingCommands());
+});
+
+add_test(function test_command_sync() {
+  _("Ensure that commands are synced across clients.");
+
+  engine._store.wipe();
+  generateNewKeys(Service.collectionKeys);
+
+  let contents = {
+    meta: {global: {engines: {clients: {version: engine.version,
+                                        syncID: engine.syncID}}}},
+    clients: {},
+    crypto: {}
+  };
+  let server   = serverForUsers({"foo": "password"}, contents);
+  new SyncTestingInfrastructure(server.server);
+
+  let user     = server.user("foo");
+  let remoteId = Utils.makeGUID();
+
+  function clientWBO(id) {
+    return user.collection("clients").wbo(id);
+  }
+
+  _("Create remote client record");
+  let rec = new ClientsRec("clients", remoteId);
+  engine._store.create(rec);
+  let remoteRecord = engine._store.createRecord(remoteId, "clients");
+  engine.sendCommand("wipeAll", []);
+
+  let clientRecord = engine._store._remoteClients[remoteId];
+  do_check_neq(clientRecord, undefined);
+  do_check_eq(clientRecord.commands.length, 1);
+
+  try {
+    _("Syncing.");
+    engine._sync();
+    _("Checking record was uploaded.");
+    do_check_neq(clientWBO(engine.localID).payload, undefined);
+    do_check_true(engine.lastRecordUpload > 0);
+
+    do_check_neq(clientWBO(remoteId).payload, undefined);
+
+    Svc.Prefs.set("client.GUID", remoteId);
+    engine._resetClient();
+    do_check_eq(engine.localID, remoteId);
+    _("Performing sync on resetted client.");
+    engine._sync();
+    do_check_neq(engine.localCommands, undefined);
+    do_check_eq(engine.localCommands.length, 1);
+
+    let command = engine.localCommands[0];
+    do_check_eq(command.command, "wipeAll");
+    do_check_eq(command.args.length, 0);
+
+  } finally {
+    Svc.Prefs.resetBranch("");
+    Service.recordManager.clearCache();
+    server.stop(run_next_test);
+  }
+});
+
+add_test(function test_send_uri_to_client_for_display() {
+  _("Ensure sendURIToClientForDisplay() sends command properly.");
+
+  let tracker = engine._tracker;
+  let store = engine._store;
+
+  let remoteId = Utils.makeGUID();
+  let rec = new ClientsRec("clients", remoteId);
+  rec.name = "remote";
+  store.create(rec);
+  let remoteRecord = store.createRecord(remoteId, "clients");
+
+  tracker.clearChangedIDs();
+  let initialScore = tracker.score;
+
+  let uri = "http://www.mozilla.org/";
+  let title = "Title of the Page";
+  engine.sendURIToClientForDisplay(uri, remoteId, title);
+
+  let newRecord = store._remoteClients[remoteId];
+
+  do_check_neq(newRecord, undefined);
+  do_check_eq(newRecord.commands.length, 1);
+
+  let command = newRecord.commands[0];
+  do_check_eq(command.command, "displayURI");
+  do_check_eq(command.args.length, 3);
+  do_check_eq(command.args[0], uri);
+  do_check_eq(command.args[1], engine.localID);
+  do_check_eq(command.args[2], title);
+
+  do_check_true(tracker.score > initialScore);
+  do_check_true(tracker.score - initialScore >= SCORE_INCREMENT_XLARGE);
+
+  _("Ensure unknown client IDs result in exception.");
+  let unknownId = Utils.makeGUID();
+  let error;
+
+  try {
+    engine.sendURIToClientForDisplay(uri, unknownId);
+  } catch (ex) {
+    error = ex;
+  }
+
+  do_check_eq(error.message.indexOf("Unknown remote client ID: "), 0);
+
+  run_next_test();
+});
+
+add_test(function test_receive_display_uri() {
+  _("Ensure processing of received 'displayURI' commands works.");
+
+  // We don't set up WBOs and perform syncing because other tests verify
+  // the command API works as advertised. This saves us a little work.
+
+  let uri = "http://www.mozilla.org/";
+  let remoteId = Utils.makeGUID();
+  let title = "Page Title!";
+
+  let command = {
+    command: "displayURI",
+    args: [uri, remoteId, title],
+  };
+
+  engine.localCommands = [command];
+
+  // Received 'displayURI' command should result in the topic defined below
+  // being called.
+  let ev = "weave:engine:clients:display-uri";
+
+  let handler = function(subject, data) {
+    Svc.Obs.remove(ev, handler);
+
+    do_check_eq(subject.uri, uri);
+    do_check_eq(subject.client, remoteId);
+    do_check_eq(subject.title, title);
+    do_check_eq(data, null);
+
+    run_next_test();
+  };
+
+  Svc.Obs.add(ev, handler);
+
+  do_check_true(engine.processIncomingCommands());
+});
+
+function run_test() {
+  initTestLogging("Trace");
+  Log.repository.getLogger("Sync.Engine.Clients").level = Log.Level.Trace;
+  run_next_test();
+}