mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
45d3f90cf3
Engines now maintain a reference to the service they belong to. This allows them to obtain references to other engine instances belonging to that service and that service only. Stores and trackers now maintain a reference to the engine they belong to. Engine managers now maintain a reference back to a service. The clients singleton has been removed. It now exists as an instance variable on Service. Parts of ClientsEngine do behave as singletons (e.g. commands). This will be addressed in future refactoring.
559 lines
16 KiB
JavaScript
559 lines
16 KiB
JavaScript
/* 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/identity.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");
|
|
|
|
const MORE_THAN_CLIENTS_TTL_REFRESH = 691200; // 8 days
|
|
const LESS_THAN_CLIENTS_TTL_REFRESH = 86400; // 1 day
|
|
|
|
let engine = Service.clientsEngine;
|
|
|
|
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();
|
|
let serverKeys = CollectionKeys.asWBO("crypto", "keys");
|
|
serverKeys.encrypt(Weave.Identity.syncKeyBundle);
|
|
do_check_true(serverKeys.upload(Weave.Service.cryptoKeysURL).success);
|
|
}
|
|
|
|
try {
|
|
let passphrase = "abcdeabcdeabcdeabcdeabcdea";
|
|
Service.serverURL = TEST_SERVER_URL;
|
|
Service.clusterURL = TEST_CLUSTER_URL;
|
|
Service.login("foo", "ilovejane", passphrase);
|
|
|
|
generateNewKeys();
|
|
|
|
_("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);
|
|
|
|
// 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();
|
|
let serverKeys = CollectionKeys.asWBO("crypto", "keys");
|
|
serverKeys.encrypt(Weave.Identity.syncKeyBundle);
|
|
do_check_true(serverKeys.upload(Weave.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();
|
|
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();
|
|
let oldKey = 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 = CollectionKeys.keyForCollection();
|
|
do_check_false(oldKey.equals(newKey));
|
|
|
|
} finally {
|
|
Svc.Prefs.resetBranch("");
|
|
Records.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.");
|
|
|
|
new SyncTestingInfrastructure();
|
|
generateNewKeys();
|
|
|
|
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");
|
|
|
|
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("");
|
|
Records.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.");
|
|
|
|
new SyncTestingInfrastructure();
|
|
|
|
engine._store.wipe();
|
|
generateNewKeys();
|
|
|
|
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");
|
|
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("");
|
|
Records.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");
|
|
Log4Moz.repository.getLogger("Sync.Engine.Clients").level = Log4Moz.Level.Trace;
|
|
run_next_test();
|
|
}
|