mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1210296 part 2 - Update tests. r=kitcambridge,markh,tcsc 

MozReview-Commit-ID: 41dnyvdlNJv

--HG--
extra : rebase_source : 4c6e3cc63d4861d176ba053a1cff872c04f0f3b3
This commit is contained in:
Edouard Oger 2017-06-05 18:49:43 -04:00
Родитель 0943c36687
Коммит 314ef330a0
84 изменённых файлов: 2071 добавлений и 2185 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

13
services/sync/modules-testing/fakeservices.js
Просмотреть файл

@ -35,25 +35,18 @@ this.FakeFilesystemService = function FakeFilesystemService(contents) {
}
}
Utils.jsonSave = function jsonSave(filePath, that, obj, callback) {
Utils.jsonSave = async function jsonSave(filePath, that, obj) {
let json = typeof obj == "function" ? obj.call(that) : obj;
self.fakeContents["weave/" + filePath + ".json"] = JSON.stringify(json);
if (callback) {
callback.call(that);
}
return Promise.resolve();
};
Utils.jsonLoad = function jsonLoad(filePath, that, cb) {
Utils.jsonLoad = async function jsonLoad(filePath, that) {
let obj;
let json = self.fakeContents["weave/" + filePath + ".json"];
if (json) {
obj = JSON.parse(json);
}
if (cb) {
cb.call(that, obj);
}
return Promise.resolve(obj);
return obj;
};
Utils.jsonMove = function jsonMove(aFrom, aTo, that) {

20
services/sync/modules-testing/rotaryengine.js
Просмотреть файл

@ -39,23 +39,23 @@ this.RotaryStore = function RotaryStore(name, engine) {
RotaryStore.prototype = {
__proto__: Store.prototype,
create: function create(record) {
async create(record) {
this.items[record.id] = record.denomination;
},
remove: function remove(record) {
async remove(record) {
delete this.items[record.id];
},
update: function update(record) {
async update(record) {
this.items[record.id] = record.denomination;
},
itemExists: function itemExists(id) {
async itemExists(id) {
return (id in this.items);
},
createRecord: function createRecord(id, collection) {
async createRecord(id, collection) {
let record = new RotaryRecord(collection, id);
if (!(id in this.items)) {
@ -67,7 +67,7 @@ RotaryStore.prototype = {
return record;
},
changeItemID: function changeItemID(oldID, newID) {
async changeItemID(oldID, newID) {
if (oldID in this.items) {
this.items[newID] = this.items[oldID];
}
@ -75,7 +75,7 @@ RotaryStore.prototype = {
delete this.items[oldID];
},
getAllIDs: function getAllIDs() {
async getAllIDs() {
let ids = {};
for (let id in this.items) {
ids[id] = true;
@ -83,7 +83,7 @@ RotaryStore.prototype = {
return ids;
},
wipe: function wipe() {
async wipe() {
this.items = {};
}
};
@ -109,8 +109,8 @@ RotaryEngine.prototype = {
_trackerObj: RotaryTracker,
_recordObj: RotaryRecord,
_findDupe: function _findDupe(item) {
// This is a semaphore used for testing proper reconciling on dupe
async _findDupe(item) {
// This is a Special Value® used for testing proper reconciling on dupe
// detection.
if (item.id == "DUPE_INCOMING") {
return "DUPE_LOCAL";

4
services/sync/tests/unit/head_errorhandler_common.js
Просмотреть файл

@ -25,7 +25,7 @@ const EHTestsCommon = {
response.bodyOutputStream.write(body, body.length);
},
sync_httpd_setup() {
async sync_httpd_setup() {
let global = new ServerWBO("global", {
syncID: Service.syncID,
storageVersion: STORAGE_VERSION,
@ -83,7 +83,7 @@ const EHTestsCommon = {
CatapultEngine.prototype = {
__proto__: SyncEngine.prototype,
exception: null, // tests fill this in
_sync: function _sync() {
async _sync() {
if (this.exception) {
throw this.exception;
}

100
services/sync/tests/unit/head_helpers.js
Просмотреть файл

@ -18,6 +18,13 @@ Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/PlacesUtils.jsm");
Cu.import("resource://gre/modules/ObjectUtils.jsm");
add_task(async function head_setup() {
// If a test imports Service, make sure it is initialized first.
if (this.Service) {
await this.Service.promiseInitialized;
}
});
// ================================================
// Load mocking/stubbing library, sinon
// docs: http://sinonjs.org/releases/v2.3.2/
@ -384,7 +391,7 @@ function wait_for_pings(expectedPings) {
async function wait_for_ping(callback, allowErrorPings, getFullPing = false) {
let pingsPromise = wait_for_pings(1);
callback();
await callback();
let [record] = await pingsPromise;
if (allowErrorPings) {
assert_valid_ping(record);
@ -407,27 +414,27 @@ function sync_and_validate_telem(allowErrorPings, getFullPing = false) {
// engine is actually synced, but we still want to ensure we're generating a
// valid ping. Returns a promise that resolves to the ping, or rejects with the
// thrown error after calling an optional callback.
function sync_engine_and_validate_telem(engine, allowErrorPings, onError) {
return new Promise((resolve, reject) => {
let telem = get_sync_test_telemetry();
let caughtError = null;
// Clear out status, so failures from previous syncs won't show up in the
// telemetry ping.
let ns = {};
Cu.import("resource://services-sync/status.js", ns);
ns.Status._engines = {};
ns.Status.partial = false;
// Ideally we'd clear these out like we do with engines, (probably via
// Status.resetSync()), but this causes *numerous* tests to fail, so we just
// assume that if no failureReason or engine failures are set, and the
// status properties are the same as they were initially, that it's just
// a leftover.
// This is only an issue since we're triggering the sync of just one engine,
// without doing any other parts of the sync.
let initialServiceStatus = ns.Status._service;
let initialSyncStatus = ns.Status._sync;
async function sync_engine_and_validate_telem(engine, allowErrorPings, onError) {
let telem = get_sync_test_telemetry();
let caughtError = null;
// Clear out status, so failures from previous syncs won't show up in the
// telemetry ping.
let ns = {};
Cu.import("resource://services-sync/status.js", ns);
ns.Status._engines = {};
ns.Status.partial = false;
// Ideally we'd clear these out like we do with engines, (probably via
// Status.resetSync()), but this causes *numerous* tests to fail, so we just
// assume that if no failureReason or engine failures are set, and the
// status properties are the same as they were initially, that it's just
// a leftover.
// This is only an issue since we're triggering the sync of just one engine,
// without doing any other parts of the sync.
let initialServiceStatus = ns.Status._service;
let initialSyncStatus = ns.Status._sync;
let oldSubmit = telem.submit;
let oldSubmit = telem.submit;
let submitPromise = new Promise((resolve, reject) => {
telem.submit = function(ping) {
telem.submit = oldSubmit;
ping.syncs.forEach(record => {
@ -472,27 +479,28 @@ function sync_engine_and_validate_telem(engine, allowErrorPings, onError) {
resolve(ping.syncs[0]);
}
}
// neuter the scheduler as it interacts badly with some of the tests - the
// engine being synced usually isn't the registered engine, so we see
// scored incremented and not removed, which schedules unexpected syncs.
let oldObserve = Service.scheduler.observe;
Service.scheduler.observe = () => {};
try {
Svc.Obs.notify("weave:service:sync:start");
try {
engine.sync();
} catch (e) {
caughtError = e;
}
if (caughtError) {
Svc.Obs.notify("weave:service:sync:error", caughtError);
} else {
Svc.Obs.notify("weave:service:sync:finish");
}
} finally {
Service.scheduler.observe = oldObserve;
}
});
// neuter the scheduler as it interacts badly with some of the tests - the
// engine being synced usually isn't the registered engine, so we see
// scored incremented and not removed, which schedules unexpected syncs.
let oldObserve = Service.scheduler.observe;
Service.scheduler.observe = () => {};
try {
Svc.Obs.notify("weave:service:sync:start");
try {
await engine.sync();
} catch (e) {
caughtError = e;
}
if (caughtError) {
Svc.Obs.notify("weave:service:sync:error", caughtError);
} else {
Svc.Obs.notify("weave:service:sync:finish");
}
} finally {
Service.scheduler.observe = oldObserve;
}
return submitPromise;
}
// Returns a promise that resolves once the specified observer notification
@ -510,12 +518,6 @@ function promiseOneObserver(topic, callback) {
function promiseStopServer(server) {
return new Promise(resolve => server.stop(resolve));
}
function promiseNextTick() {
return new Promise(resolve => {
Utils.nextTick(resolve);
});
}
// Avoid an issue where `client.name2` containing unicode characters causes
// a number of tests to fail, due to them assuming that we do not need to utf-8
// encode or decode data sent through the mocked server (see bug 1268912).
@ -525,12 +527,12 @@ Utils.getDefaultDeviceName = function() {
return "Test device name";
};
function registerRotaryEngine() {
async function registerRotaryEngine() {
let {RotaryEngine} =
Cu.import("resource://testing-common/services/sync/rotaryengine.js", {});
Service.engineManager.clear();
Service.engineManager.register(RotaryEngine);
await Service.engineManager.register(RotaryEngine);
let engine = Service.engineManager.get("rotary");
engine.enabled = true;

101
services/sync/tests/unit/test_addons_engine.js
Просмотреть файл

@ -13,36 +13,54 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
var prefs = new Preferences();
const prefs = new Preferences();
prefs.set("extensions.getAddons.get.url",
"http://localhost:8888/search/guid:%IDS%");
prefs.set("extensions.install.requireSecureOrigin", false);
loadAddonTestFunctions();
startupManager();
let engine;
let reconciler;
let tracker;
var engineManager = Service.engineManager;
engineManager.register(AddonsEngine);
var engine = engineManager.get("addons");
var reconciler = engine._reconciler;
var tracker = engine._tracker;
function advance_test() {
async function resetReconciler() {
reconciler._addons = {};
reconciler._changes = [];
let cb = Async.makeSpinningCallback();
reconciler.saveState(null, cb);
cb.wait();
await reconciler.saveState();
tracker.clearChangedIDs();
run_next_test();
}
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Addons").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.Store.Addons").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Tracker.Addons").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsRepository").level =
Log.Level.Trace;
loadAddonTestFunctions();
startupManager();
await Service.engineManager.register(AddonsEngine);
engine = Service.engineManager.get("addons");
reconciler = engine._reconciler;
tracker = engine._tracker;
reconciler.startListening();
// Don't flush to disk in the middle of an event listener!
// This causes test hangs on WinXP.
reconciler._shouldPersist = false;
await resetReconciler();
});
// This is a basic sanity test for the unit test itself. If this breaks, the
// add-ons API likely changed upstream.
add_test(function test_addon_install() {
add_task(async function test_addon_install() {
_("Ensure basic add-on APIs work as expected.");
let install = getAddonInstall("test_bootstrap1_1");
@ -50,15 +68,15 @@ add_test(function test_addon_install() {
do_check_eq(install.type, "extension");
do_check_eq(install.name, "Test Bootstrap 1");
advance_test();
await resetReconciler();
});
add_test(function test_find_dupe() {
add_task(async function test_find_dupe() {
_("Ensure the _findDupe() implementation is sane.");
// This gets invoked at the top of sync, which is bypassed by this
// test, so we do it manually.
engine._refreshReconcilerState();
await engine._refreshReconcilerState();
let addon = installAddon("test_bootstrap1_1");
@ -70,22 +88,22 @@ add_test(function test_find_dupe() {
source: "amo"
};
let dupe = engine._findDupe(record);
let dupe = await engine._findDupe(record);
do_check_eq(addon.syncGUID, dupe);
record.id = addon.syncGUID;
dupe = engine._findDupe(record);
dupe = await engine._findDupe(record);
do_check_eq(null, dupe);
uninstallAddon(addon);
advance_test();
await resetReconciler();
});
add_test(function test_get_changed_ids() {
add_task(async function test_get_changed_ids() {
_("Ensure getChangedIDs() has the appropriate behavior.");
_("Ensure getChangedIDs() returns an empty object by default.");
let changes = engine.getChangedIDs();
let changes = await engine.getChangedIDs();
do_check_eq("object", typeof(changes));
do_check_eq(0, Object.keys(changes).length);
@ -95,7 +113,7 @@ add_test(function test_get_changed_ids() {
let guid1 = Utils.makeGUID();
tracker.addChangedID(guid1, changeTime);
changes = engine.getChangedIDs();
changes = await engine.getChangedIDs();
do_check_eq("object", typeof(changes));
do_check_eq(1, Object.keys(changes).length);
do_check_true(guid1 in changes);
@ -106,7 +124,7 @@ add_test(function test_get_changed_ids() {
_("Ensure reconciler changes are populated.");
let addon = installAddon("test_bootstrap1_1");
tracker.clearChangedIDs(); // Just in case.
changes = engine.getChangedIDs();
changes = await engine.getChangedIDs();
do_check_eq("object", typeof(changes));
do_check_eq(1, Object.keys(changes).length);
do_check_true(addon.syncGUID in changes);
@ -116,7 +134,7 @@ add_test(function test_get_changed_ids() {
let oldTime = changes[addon.syncGUID];
let guid2 = addon.syncGUID;
uninstallAddon(addon);
changes = engine.getChangedIDs();
changes = await engine.getChangedIDs();
do_check_eq(1, Object.keys(changes).length);
do_check_true(guid2 in changes);
do_check_true(changes[guid2] > oldTime);
@ -137,11 +155,11 @@ add_test(function test_get_changed_ids() {
reconciler.addons["DUMMY"] = record;
reconciler._addChange(record.modified, CHANGE_INSTALLED, record);
changes = engine.getChangedIDs();
changes = await engine.getChangedIDs();
_(JSON.stringify(changes));
do_check_eq(0, Object.keys(changes).length);
advance_test();
await resetReconciler();
});
add_task(async function test_disabled_install_semantics() {
@ -194,7 +212,7 @@ add_task(async function test_disabled_install_semantics() {
server.insertWBO(USER, "addons", wbo);
_("Performing sync of add-ons engine.");
engine._sync();
await engine._sync();
// At this point the non-restartless extension should be staged for install.
@ -210,7 +228,7 @@ add_task(async function test_disabled_install_semantics() {
// are sane.
restartManager();
engine._sync();
await engine._sync();
// The client should not upload a new record. The old record should be
// retained and unmodified.
@ -222,7 +240,7 @@ add_task(async function test_disabled_install_semantics() {
do_check_eq(ADDON_ID, payload.addonID);
do_check_false(payload.enabled);
promiseStopServer(server);
await promiseStopServer(server);
});
add_test(function cleanup() {
@ -230,22 +248,3 @@ add_test(function cleanup() {
reconciler.stopListening();
run_next_test();
});
function run_test() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Addons").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.Store.Addons").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Tracker.Addons").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsRepository").level =
Log.Level.Trace;
reconciler.startListening();
// Don't flush to disk in the middle of an event listener!
// This causes test hangs on WinXP.
reconciler._shouldPersist = false;
advance_test();
}

67
services/sync/tests/unit/test_addons_reconciler.js
Просмотреть файл

@ -12,53 +12,48 @@ Cu.import("resource://services-sync/util.js");
loadAddonTestFunctions();
startupManager();
function run_test() {
add_task(async function run_test() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.AddonsReconciler").level = Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsReconciler").level =
Log.Level.Trace;
Svc.Prefs.set("engine.addons", true);
Service.engineManager.register(AddonsEngine);
await Service.engineManager.register(AddonsEngine);
});
run_next_test();
}
add_test(function test_defaults() {
add_task(async function test_defaults() {
_("Ensure new objects have reasonable defaults.");
let reconciler = new AddonsReconciler();
await reconciler.ensureStateLoaded();
do_check_false(reconciler._listening);
do_check_eq("object", typeof(reconciler.addons));
do_check_eq(0, Object.keys(reconciler.addons).length);
do_check_eq(0, reconciler._changes.length);
do_check_eq(0, reconciler._listeners.length);
run_next_test();
});
add_test(function test_load_state_empty_file() {
add_task(async function test_load_state_empty_file() {
_("Ensure loading from a missing file results in defaults being set.");
let reconciler = new AddonsReconciler();
await reconciler.ensureStateLoaded();
reconciler.loadState(null, function(error, loaded) {
do_check_eq(null, error);
do_check_false(loaded);
let loaded = await reconciler.loadState();
do_check_false(loaded);
do_check_eq("object", typeof(reconciler.addons));
do_check_eq(0, Object.keys(reconciler.addons).length);
do_check_eq(0, reconciler._changes.length);
run_next_test();
});
do_check_eq("object", typeof(reconciler.addons));
do_check_eq(0, Object.keys(reconciler.addons).length);
do_check_eq(0, reconciler._changes.length);
});
add_test(function test_install_detection() {
add_task(async function test_install_detection() {
_("Ensure that add-on installation results in appropriate side-effects.");
let reconciler = new AddonsReconciler();
await reconciler.ensureStateLoaded();
reconciler.startListening();
let before = new Date();
@ -91,14 +86,13 @@ add_test(function test_install_detection() {
do_check_eq(addon.id, change[2]);
uninstallAddon(addon);
run_next_test();
});
add_test(function test_uninstall_detection() {
add_task(async function test_uninstall_detection() {
_("Ensure that add-on uninstallation results in appropriate side-effects.");
let reconciler = new AddonsReconciler();
await reconciler.ensureStateLoaded();
reconciler.startListening();
reconciler._addons = {};
@ -120,43 +114,36 @@ add_test(function test_uninstall_detection() {
let change = reconciler._changes[0];
do_check_eq(CHANGE_UNINSTALLED, change[1]);
do_check_eq(id, change[2]);
run_next_test();
});
add_test(function test_load_state_future_version() {
add_task(async function test_load_state_future_version() {
_("Ensure loading a file from a future version results in no data loaded.");
const FILENAME = "TEST_LOAD_STATE_FUTURE_VERSION";
let reconciler = new AddonsReconciler();
await reconciler.ensureStateLoaded();
// First we populate our new file.
let state = {version: 100, addons: {foo: {}}, changes: [[1, 1, "foo"]]};
let cb = Async.makeSyncCallback();
// jsonSave() expects an object with ._log, so we give it a reconciler
// instance.
Utils.jsonSave(FILENAME, reconciler, state, cb);
Async.waitForSyncCallback(cb);
await Utils.jsonSave(FILENAME, reconciler, state);
reconciler.loadState(FILENAME, function(error, loaded) {
do_check_eq(null, error);
do_check_false(loaded);
let loaded = await reconciler.loadState(FILENAME);
do_check_false(loaded);
do_check_eq("object", typeof(reconciler.addons));
do_check_eq(1, Object.keys(reconciler.addons).length);
do_check_eq(1, reconciler._changes.length);
run_next_test();
});
do_check_eq("object", typeof(reconciler.addons));
do_check_eq(0, Object.keys(reconciler.addons).length);
do_check_eq(0, reconciler._changes.length);
});
add_test(function test_prune_changes_before_date() {
add_task(async function test_prune_changes_before_date() {
_("Ensure that old changes are pruned properly.");
let reconciler = new AddonsReconciler();
reconciler._ensureStateLoaded();
await reconciler.ensureStateLoaded();
reconciler._changes = [];
let now = new Date();
@ -189,6 +176,4 @@ add_test(function test_prune_changes_before_date() {
reconciler._changes.push([old, CHANGE_INSTALLED, "foo"]);
reconciler.pruneChangesBeforeDate(now);
do_check_eq(0, reconciler._changes.length);
run_next_test();
});

126
services/sync/tests/unit/test_addons_store.js
Просмотреть файл

@ -14,7 +14,7 @@ Cu.import("resource://gre/modules/FileUtils.jsm");
const HTTP_PORT = 8888;
var prefs = new Preferences();
const prefs = new Preferences();
prefs.set("extensions.getAddons.get.url", "http://localhost:8888/search/guid:%IDS%");
prefs.set("extensions.install.requireSecureOrigin", false);
@ -39,11 +39,10 @@ loadAddonTestFunctions();
loadSystemAddon();
startupManager();
Service.engineManager.register(AddonsEngine);
var engine = Service.engineManager.get("addons");
var tracker = engine._tracker;
var store = engine._store;
var reconciler = engine._reconciler;
let engine;
let tracker;
let store;
let reconciler;
/**
* Create a AddonsRec for this application with the fields specified.
@ -103,38 +102,39 @@ function checkReconcilerUpToDate(addon) {
deepEqual(stateBefore, stateAfter);
}
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Addons").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Tracker.Addons").level = Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsRepository").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsRepository").level = Log.Level.Trace;
await Service.engineManager.register(AddonsEngine);
engine = Service.engineManager.get("addons");
tracker = engine._tracker;
store = engine._store;
reconciler = engine._reconciler;
reconciler.startListening();
// Don't flush to disk in the middle of an event listener!
// This causes test hangs on WinXP.
reconciler._shouldPersist = false;
});
run_next_test();
}
add_test(function test_remove() {
add_task(async function test_remove() {
_("Ensure removing add-ons from deleted records works.");
let addon = installAddon("test_bootstrap1_1");
let record = createRecordForThisApp(addon.syncGUID, addon.id, true, true);
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(0, failed.length);
let newAddon = getAddonFromAddonManagerByID(addon.id);
do_check_eq(null, newAddon);
run_next_test();
});
add_test(function test_apply_enabled() {
add_task(async function test_apply_enabled() {
_("Ensures that changes to the userEnabled flag apply.");
let addon = installAddon("test_bootstrap1_1");
@ -144,7 +144,7 @@ add_test(function test_apply_enabled() {
_("Ensure application of a disable record works as expected.");
let records = [];
records.push(createRecordForThisApp(addon.syncGUID, addon.id, false, false));
let failed = store.applyIncomingBatch(records);
let failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_true(addon.userDisabled);
@ -153,7 +153,7 @@ add_test(function test_apply_enabled() {
_("Ensure enable record works as expected.");
records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, false));
failed = store.applyIncomingBatch(records);
failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_false(addon.userDisabled);
@ -163,7 +163,7 @@ add_test(function test_apply_enabled() {
_("Ensure enabled state updates don't apply if the ignore pref is set.");
records.push(createRecordForThisApp(addon.syncGUID, addon.id, false, false));
Svc.Prefs.set("addons.ignoreUserEnabledChanges", true);
failed = store.applyIncomingBatch(records);
failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_false(addon.userDisabled);
@ -171,10 +171,9 @@ add_test(function test_apply_enabled() {
uninstallAddon(addon);
Svc.Prefs.reset("addons.ignoreUserEnabledChanges");
run_next_test();
});
add_test(function test_apply_enabled_appDisabled() {
add_task(async function test_apply_enabled_appDisabled() {
_("Ensures that changes to the userEnabled flag apply when the addon is appDisabled.");
let addon = installAddon("test_install3"); // this addon is appDisabled by default.
@ -187,7 +186,7 @@ add_test(function test_apply_enabled_appDisabled() {
store.reconciler._changes = [];
let records = [];
records.push(createRecordForThisApp(addon.syncGUID, addon.id, false, false));
let failed = store.applyIncomingBatch(records);
let failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_true(addon.userDisabled);
@ -196,7 +195,7 @@ add_test(function test_apply_enabled_appDisabled() {
_("Ensure enable record works as expected.");
records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, false));
failed = store.applyIncomingBatch(records);
failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_false(addon.userDisabled);
@ -204,10 +203,9 @@ add_test(function test_apply_enabled_appDisabled() {
records = [];
uninstallAddon(addon);
run_next_test();
});
add_test(function test_ignore_different_appid() {
add_task(async function test_ignore_different_appid() {
_("Ensure that incoming records with a different application ID are ignored.");
// We test by creating a record that should result in an update.
@ -217,18 +215,16 @@ add_test(function test_ignore_different_appid() {
let record = createRecordForThisApp(addon.syncGUID, addon.id, false, false);
record.applicationID = "FAKE_ID";
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(0, failed.length);
let newAddon = getAddonFromAddonManagerByID(addon.id);
do_check_false(newAddon.userDisabled);
uninstallAddon(addon);
run_next_test();
});
add_test(function test_ignore_unknown_source() {
add_task(async function test_ignore_unknown_source() {
_("Ensure incoming records with unknown source are ignored.");
let addon = installAddon("test_bootstrap1_1");
@ -236,31 +232,27 @@ add_test(function test_ignore_unknown_source() {
let record = createRecordForThisApp(addon.syncGUID, addon.id, false, false);
record.source = "DUMMY_SOURCE";
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(0, failed.length);
let newAddon = getAddonFromAddonManagerByID(addon.id);
do_check_false(newAddon.userDisabled);
uninstallAddon(addon);
run_next_test();
});
add_test(function test_apply_uninstall() {
add_task(async function test_apply_uninstall() {
_("Ensures that uninstalling an add-on from a record works.");
let addon = installAddon("test_bootstrap1_1");
let records = [];
records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, true));
let failed = store.applyIncomingBatch(records);
let failed = await store.applyIncomingBatch(records);
do_check_eq(0, failed.length);
addon = getAddonFromAddonManagerByID(addon.id);
do_check_eq(null, addon);
run_next_test();
});
add_test(function test_addon_syncability() {
@ -380,7 +372,7 @@ add_test(function test_ignore_hotfixes() {
});
add_test(function test_get_all_ids() {
add_task(async function test_get_all_ids() {
_("Ensures that getAllIDs() returns an appropriate set.");
_("Installing two addons.");
@ -399,7 +391,7 @@ add_test(function test_get_all_ids() {
do_check_true(store.isAddonSyncable(addon2));
do_check_true(store.isAddonSyncable(addon3));
let ids = store.getAllIDs();
let ids = await store.getAllIDs();
do_check_eq("object", typeof(ids));
do_check_eq(3, Object.keys(ids).length);
@ -410,11 +402,9 @@ add_test(function test_get_all_ids() {
addon1.install.cancel();
uninstallAddon(addon2);
uninstallAddon(addon3);
run_next_test();
});
add_test(function test_change_item_id() {
add_task(async function test_change_item_id() {
_("Ensures that changeItemID() works properly.");
let addon = installAddon("test_bootstrap1_1");
@ -422,18 +412,16 @@ add_test(function test_change_item_id() {
let oldID = addon.syncGUID;
let newID = Utils.makeGUID();
store.changeItemID(oldID, newID);
await store.changeItemID(oldID, newID);
let newAddon = getAddonFromAddonManagerByID(addon.id);
do_check_neq(null, newAddon);
do_check_eq(newID, newAddon.syncGUID);
uninstallAddon(newAddon);
run_next_test();
});
add_test(function test_create() {
add_task(async function test_create() {
_("Ensure creating/installing an add-on from a record works.");
let server = createAndStartHTTPServer(HTTP_PORT);
@ -445,7 +433,7 @@ add_test(function test_create() {
let guid = Utils.makeGUID();
let record = createRecordForThisApp(guid, id, true, false);
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(0, failed.length);
let newAddon = getAddonFromAddonManagerByID(id);
@ -455,10 +443,10 @@ add_test(function test_create() {
uninstallAddon(newAddon);
server.stop(run_next_test);
await promiseStopServer(server);
});
add_test(function test_create_missing_search() {
add_task(async function test_create_missing_search() {
_("Ensures that failed add-on searches are handled gracefully.");
let server = createAndStartHTTPServer(HTTP_PORT);
@ -468,17 +456,17 @@ add_test(function test_create_missing_search() {
let guid = Utils.makeGUID();
let record = createRecordForThisApp(guid, id, true, false);
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(1, failed.length);
do_check_eq(guid, failed[0]);
let addon = getAddonFromAddonManagerByID(id);
do_check_eq(null, addon);
server.stop(run_next_test);
await promiseStopServer(server);
});
add_test(function test_create_bad_install() {
add_task(async function test_create_bad_install() {
_("Ensures that add-ons without a valid install are handled gracefully.");
let server = createAndStartHTTPServer(HTTP_PORT);
@ -488,7 +476,7 @@ add_test(function test_create_bad_install() {
let guid = Utils.makeGUID();
let record = createRecordForThisApp(guid, id, true, false);
/* let failed = */ store.applyIncomingBatch([record]);
/* let failed = */ await store.applyIncomingBatch([record]);
// This addon had no source URI so was skipped - but it's not treated as
// failure.
// XXX - this test isn't testing what we thought it was. Previously the addon
@ -505,24 +493,24 @@ add_test(function test_create_bad_install() {
let addon = getAddonFromAddonManagerByID(id);
do_check_eq(null, addon);
server.stop(run_next_test);
await promiseStopServer(server);
});
add_test(function test_ignore_system() {
add_task(async function test_ignore_system() {
_("Ensure we ignore system addons");
// Our system addon should not appear in getAllIDs
engine._refreshReconcilerState();
await engine._refreshReconcilerState();
let num = 0;
for (let guid in store.getAllIDs()) {
let ids = await store.getAllIDs();
for (let guid in ids) {
num += 1;
let addon = reconciler.getAddonStateFromSyncGUID(guid);
do_check_neq(addon.id, SYSTEM_ADDON_ID);
}
do_check_true(num > 1, "should have seen at least one.")
run_next_test();
do_check_true(num > 1, "should have seen at least one.");
});
add_test(function test_incoming_system() {
add_task(async function test_incoming_system() {
_("Ensure we handle incoming records that refer to a system addon");
// eg, loop initially had a normal addon but it was then "promoted" to be a
// system addon but wanted to keep the same ID. The server record exists due
@ -539,29 +527,27 @@ add_test(function test_incoming_system() {
let guid = Utils.makeGUID();
let record = createRecordForThisApp(guid, SYSTEM_ADDON_ID, false, false);
let failed = store.applyIncomingBatch([record]);
let failed = await store.applyIncomingBatch([record]);
do_check_eq(0, failed.length);
// The system addon should still not be userDisabled.
do_check_false(getAddonFromAddonManagerByID(SYSTEM_ADDON_ID).userDisabled);
server.stop(run_next_test);
await promiseStopServer(server);
});
add_test(function test_wipe() {
add_task(async function test_wipe() {
_("Ensures that wiping causes add-ons to be uninstalled.");
let addon1 = installAddon("test_bootstrap1_1");
store.wipe();
await store.wipe();
let addon = getAddonFromAddonManagerByID(addon1.id);
do_check_eq(null, addon);
run_next_test();
});
add_test(function test_wipe_and_install() {
add_task(async function test_wipe_and_install() {
_("Ensure wipe followed by install works.");
// This tests the reset sync flow where remote data is replaced by local. The
@ -572,7 +558,7 @@ add_test(function test_wipe_and_install() {
let record = createRecordForThisApp(installed.syncGUID, installed.id, true,
false);
store.wipe();
await store.wipe();
let deleted = getAddonFromAddonManagerByID(installed.id);
do_check_null(deleted);
@ -580,12 +566,12 @@ add_test(function test_wipe_and_install() {
// Re-applying the record can require re-fetching the XPI.
let server = createAndStartHTTPServer(HTTP_PORT);
store.applyIncoming(record);
await store.applyIncoming(record);
let fetched = getAddonFromAddonManagerByID(record.addonID);
do_check_true(!!fetched);
server.stop(run_next_test);
await promiseStopServer(server);
});
add_test(function cleanup() {

66
services/sync/tests/unit/test_addons_tracker.js
Просмотреть файл

@ -13,18 +13,14 @@ loadAddonTestFunctions();
startupManager();
Svc.Prefs.set("engine.addons", true);
Service.engineManager.register(AddonsEngine);
var engine = Service.engineManager.get("addons");
var reconciler = engine._reconciler;
var store = engine._store;
var tracker = engine._tracker;
// Don't write out by default.
tracker.persistChangedIDs = false;
let engine;
let reconciler;
let store;
let tracker;
const addon1ID = "addon1@tests.mozilla.org";
function cleanup_and_advance() {
async function cleanup() {
Svc.Obs.notify("weave:engine:stop-tracking");
tracker.stopTracking();
@ -33,32 +29,36 @@ function cleanup_and_advance() {
reconciler._addons = {};
reconciler._changes = [];
let cb = Async.makeSpinningCallback();
reconciler.saveState(null, cb);
cb.wait();
run_next_test();
await reconciler.saveState();
}
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Addons").level = Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsReconciler").level =
Log.Level.Trace;
Log.repository.getLogger("Sync.AddonsReconciler").level = Log.Level.Trace;
cleanup_and_advance();
}
await Service.engineManager.register(AddonsEngine);
engine = Service.engineManager.get("addons");
reconciler = engine._reconciler;
store = engine._store;
tracker = engine._tracker;
add_test(function test_empty() {
// Don't write out by default.
tracker.persistChangedIDs = false;
await cleanup();
});
add_task(async function test_empty() {
_("Verify the tracker is empty to start with.");
do_check_eq(0, Object.keys(tracker.changedIDs).length);
do_check_eq(0, tracker.score);
cleanup_and_advance();
await cleanup();
});
add_test(function test_not_tracking() {
add_task(async function test_not_tracking() {
_("Ensures the tracker doesn't do anything when it isn't tracking.");
let addon = installAddon("test_bootstrap1_1");
@ -67,10 +67,10 @@ add_test(function test_not_tracking() {
do_check_eq(0, Object.keys(tracker.changedIDs).length);
do_check_eq(0, tracker.score);
cleanup_and_advance();
await cleanup();
});
add_test(function test_track_install() {
add_task(async function test_track_install() {
_("Ensure that installing an add-on notifies tracker.");
reconciler.startListening();
@ -86,10 +86,10 @@ add_test(function test_track_install() {
do_check_eq(SCORE_INCREMENT_XLARGE, tracker.score);
uninstallAddon(addon);
cleanup_and_advance();
await cleanup();
});
add_test(function test_track_uninstall() {
add_task(async function test_track_uninstall() {
_("Ensure that uninstalling an add-on notifies tracker.");
reconciler.startListening();
@ -106,10 +106,10 @@ add_test(function test_track_uninstall() {
do_check_true(guid in changed);
do_check_eq(SCORE_INCREMENT_XLARGE, tracker.score);
cleanup_and_advance();
await cleanup();
});
add_test(function test_track_user_disable() {
add_task(async function test_track_user_disable() {
_("Ensure that tracker sees disabling of add-on");
reconciler.startListening();
@ -149,23 +149,23 @@ add_test(function test_track_user_disable() {
do_check_eq(SCORE_INCREMENT_XLARGE, tracker.score);
uninstallAddon(addon);
cleanup_and_advance();
await cleanup();
});
add_test(function test_track_enable() {
add_task(async function test_track_enable() {
_("Ensure that enabling a disabled add-on notifies tracker.");
reconciler.startListening();
let addon = installAddon("test_bootstrap1_1");
addon.userDisabled = true;
store._sleep(0);
await Async.promiseYield();
do_check_eq(0, tracker.score);
Svc.Obs.notify("weave:engine:start-tracking");
addon.userDisabled = false;
store._sleep(0);
await Async.promiseYield();
let changed = tracker.changedIDs;
do_check_eq(1, Object.keys(changed).length);
@ -173,5 +173,5 @@ add_test(function test_track_enable() {
do_check_eq(SCORE_INCREMENT_XLARGE, tracker.score);
uninstallAddon(addon);
cleanup_and_advance();
await cleanup();
});

9
services/sync/tests/unit/test_bookmark_batch_fail.js
Просмотреть файл

@ -5,18 +5,19 @@ _("Making sure a failing sync reports a useful error");
Cu.import("resource://services-sync/engines/bookmarks.js");
Cu.import("resource://services-sync/service.js");
function run_test() {
add_task(async function run_test() {
let engine = new BookmarksEngine(Service);
engine._syncStartup = function() {
await engine.initialize();
engine._syncStartup = async function() {
throw "FAIL!";
};
try {
_("Try calling the sync that should throw right away");
engine._sync();
await engine._sync();
do_throw("Should have failed sync!");
} catch (ex) {
_("Making sure what we threw ended up as the exception:", ex);
do_check_eq(ex, "FAIL!");
}
}
});

13
services/sync/tests/unit/test_bookmark_decline_undecline.js
Просмотреть файл

@ -11,9 +11,10 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging("Trace");
Service.engineManager.register(BookmarksEngine);
add_task(async function setup() {
initTestLogging("Trace");
await Service.engineManager.register(BookmarksEngine);
});
// A stored reference to the collection won't be valid after disabling.
function getBookmarkWBO(server, guid) {
@ -38,15 +39,15 @@ add_task(async function test_decline_undecline() {
});
ok(!getBookmarkWBO(server, bzGuid), "Shouldn't have been uploaded yet");
Service.sync();
await Service.sync();
ok(getBookmarkWBO(server, bzGuid), "Should be present on server");
engine.enabled = false;
Service.sync();
await Service.sync();
ok(!getBookmarkWBO(server, bzGuid), "Shouldn't be present on server anymore");
engine.enabled = true;
Service.sync();
await Service.sync();
ok(getBookmarkWBO(server, bzGuid), "Should be present on server again");
} finally {

83
services/sync/tests/unit/test_bookmark_duping.js
Просмотреть файл

@ -11,19 +11,20 @@ Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Cu.import("resource://services-sync/bookmark_validator.js");
initTestLogging("Trace");
const bms = PlacesUtils.bookmarks;
let engine;
let store;
Service.engineManager.register(BookmarksEngine);
add_task(async function setup() {
initTestLogging("Trace");
await Service.engineManager.register(BookmarksEngine);
engine = Service.engineManager.get("bookmarks");
store = engine._store;
store._log.level = Log.Level.Trace;
engine._log.level = Log.Level.Trace;
});
const engine = new BookmarksEngine(Service);
const store = engine._store;
store._log.level = Log.Level.Trace;
engine._log.level = Log.Level.Trace;
async function setup() {
async function sharedSetup() {
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -37,14 +38,14 @@ async function setup() {
async function cleanup(server) {
Svc.Obs.notify("weave:engine:stop-tracking");
let promiseStartOver = promiseOneObserver("weave:service:start-over:finish");
Service.startOver();
await Service.startOver();
await promiseStartOver;
await promiseStopServer(server);
await bms.eraseEverything();
}
async function syncIdToId(syncId) {
let guid = await PlacesSyncUtils.bookmarks.syncIdToGuid(syncId);
let guid = PlacesSyncUtils.bookmarks.syncIdToGuid(syncId);
return PlacesUtils.promiseItemId(guid);
}
@ -121,14 +122,14 @@ async function validate(collection, expectedFailures = []) {
add_task(async function test_dupe_bookmark() {
_("Ensure that a bookmark we consider a dupe is handled correctly.");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
let {id: folder1_id, guid: folder1_guid } = await createFolder(bms.toolbarFolder, "Folder 1");
let {id: localId, guid: bmk1_guid} = await createBookmark(folder1_id, "http://getfirefox.com/", "Get Firefox!");
engine.sync();
await engine.sync();
// We've added the bookmark, its parent (folder1) plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 6);
@ -165,7 +166,7 @@ add_task(async function test_dupe_bookmark() {
_("Syncing so new dupe record is processed");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// We should have logically deleted the dupe record.
equal(collection.count(), 7);
@ -192,7 +193,7 @@ add_task(async function test_dupe_bookmark() {
add_task(async function test_dupe_reparented_bookmark() {
_("Ensure that a bookmark we consider a dupe from a different parent is handled correctly");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
@ -203,7 +204,7 @@ add_task(async function test_dupe_reparented_bookmark() {
do_print(`folder1_guid=${folder1_guid}, folder2_guid=${folder2_guid}, bmk1_guid=${bmk1_guid}`);
engine.sync();
await engine.sync();
// We've added the bookmark, 2 folders plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 7);
@ -226,7 +227,7 @@ add_task(async function test_dupe_reparented_bookmark() {
_("Syncing so new dupe record is processed");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// We should have logically deleted the dupe record.
equal(collection.count(), 8);
@ -258,7 +259,7 @@ add_task(async function test_dupe_reparented_bookmark() {
add_task(async function test_dupe_reparented_locally_changed_bookmark() {
_("Ensure that a bookmark with local changes we consider a dupe from a different parent is handled correctly");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
@ -269,7 +270,7 @@ add_task(async function test_dupe_reparented_locally_changed_bookmark() {
do_print(`folder1_guid=${folder1_guid}, folder2_guid=${folder2_guid}, bmk1_guid=${bmk1_guid}`);
engine.sync();
await engine.sync();
// We've added the bookmark, 2 folders plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 7);
@ -303,7 +304,7 @@ add_task(async function test_dupe_reparented_locally_changed_bookmark() {
_("Syncing so new dupe record is processed");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// We should have logically deleted the dupe record.
equal(collection.count(), 8);
@ -336,7 +337,7 @@ add_task(async function test_dupe_reparented_to_earlier_appearing_parent_bookmar
_("Ensure that a bookmark we consider a dupe from a different parent that " +
"appears in the same sync before the dupe item");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
@ -347,7 +348,7 @@ add_task(async function test_dupe_reparented_to_earlier_appearing_parent_bookmar
do_print(`folder1=${folder1_guid}, bmk1=${bmk1_guid} folder2=${folder2_guid}`);
engine.sync();
await engine.sync();
// We've added the bookmark, 2 folders plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 7);
@ -394,12 +395,12 @@ add_task(async function test_dupe_reparented_to_earlier_appearing_parent_bookmar
_("Syncing so new records are processed.");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// Everything should be parented correctly.
equal((await getFolderChildrenIDs(folder1_id)).length, 0);
let newParentID = store.idForGUID(newParentGUID);
let newID = store.idForGUID(newGUID);
let newParentID = await store.idForGUID(newParentGUID);
let newID = await store.idForGUID(newGUID);
deepEqual(await getFolderChildrenIDs(newParentID), [newID]);
// Make sure the validator thinks everything is hunky-dory.
@ -413,7 +414,7 @@ add_task(async function test_dupe_reparented_to_later_appearing_parent_bookmark(
_("Ensure that a bookmark we consider a dupe from a different parent that " +
"doesn't exist locally as we process the child, but does appear in the same sync");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
@ -424,7 +425,7 @@ add_task(async function test_dupe_reparented_to_later_appearing_parent_bookmark(
do_print(`folder1=${folder1_guid}, bmk1=${bmk1_guid} folder2=${folder2_guid}`);
engine.sync();
await engine.sync();
// We've added the bookmark, 2 folders plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 7);
@ -470,13 +471,13 @@ add_task(async function test_dupe_reparented_to_later_appearing_parent_bookmark(
_("Syncing so out-of-order records are processed.");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// The intended parent did end up existing, so it should be parented
// correctly after de-duplication.
equal((await getFolderChildrenIDs(folder1_id)).length, 0);
let newParentID = store.idForGUID(newParentGUID);
let newID = store.idForGUID(newGUID);
let newParentID = await store.idForGUID(newParentGUID);
let newID = await store.idForGUID(newGUID);
deepEqual(await getFolderChildrenIDs(newParentID), [newID]);
// Make sure the validator thinks everything is hunky-dory.
@ -490,7 +491,7 @@ add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark(
_("Ensure that a bookmark we consider a dupe from a different parent that " +
"doesn't exist locally and doesn't appear in this Sync is handled correctly");
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The parent folder and one bookmark in it.
@ -501,7 +502,7 @@ add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark(
do_print(`folder1=${folder1_guid}, bmk1=${bmk1_guid} folder2=${folder2_guid}`);
engine.sync();
await engine.sync();
// We've added the bookmark, 2 folders plus "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 7);
@ -526,7 +527,7 @@ add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark(
_("Syncing so new dupe record is processed");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// We should have logically deleted the dupe record.
equal(collection.count(), 8);
@ -543,7 +544,7 @@ add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark(
// As the incoming parent is missing the item should have been annotated
// with that missing parent.
equal(PlacesUtils.annotations.getItemAnnotation(store.idForGUID(newGUID), "sync/parent"),
equal(PlacesUtils.annotations.getItemAnnotation((await store.idForGUID(newGUID)), "sync/parent"),
newParentGUID);
// Check the validator. Sadly, this is known to cause a mismatch between
@ -582,12 +583,12 @@ add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark(
_("Syncing so missing parent appears");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
// The intended parent now does exist, so it should have been reparented.
equal((await getFolderChildrenIDs(folder1_id)).length, 0);
let newParentID = store.idForGUID(newParentGUID);
let newID = store.idForGUID(newGUID);
let newParentID = await store.idForGUID(newParentGUID);
let newID = await store.idForGUID(newGUID);
deepEqual(await getFolderChildrenIDs(newParentID), [newID]);
// validation now has different errors :(
@ -614,13 +615,13 @@ add_task(async function test_dupe_empty_folder() {
_("Ensure that an empty folder we consider a dupe is handled correctly.");
// Empty folders aren't particularly interesting in practice (as that seems
// an edge-case) but duping folders with items is broken - bug 1293163.
let { server, collection } = await this.setup();
let { server, collection } = await this.sharedSetup();
try {
// The folder we will end up duping away.
let {guid: folder1_guid } = await createFolder(bms.toolbarFolder, "Folder 1");
engine.sync();
await engine.sync();
// We've added 1 folder, "menu", "toolbar", "unfiled", and "mobile".
equal(collection.count(), 5);
@ -638,7 +639,7 @@ add_task(async function test_dupe_empty_folder() {
_("Syncing so new dupe records are processed");
engine.lastSync = engine.lastSync - 5;
engine.sync();
await engine.sync();
await validate(collection);

89
services/sync/tests/unit/test_bookmark_engine.js
Просмотреть файл

@ -39,6 +39,7 @@ add_task(async function test_delete_invalid_roots_from_server() {
_("Ensure that we delete the Places and Reading List roots from the server.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -48,7 +49,8 @@ add_task(async function test_delete_invalid_roots_from_server() {
Svc.Obs.notify("weave:engine:start-tracking");
try {
collection.insert("places", encryptPayload(store.createRecord("places").cleartext));
let placesRecord = await store.createRecord("places");
collection.insert("places", encryptPayload(placesRecord.cleartext));
let listBmk = new Bookmark("bookmarks", Utils.makeGUID());
listBmk.bmkUri = "https://example.com";
@ -76,14 +78,14 @@ add_task(async function test_delete_invalid_roots_from_server() {
await sync_engine_and_validate_telem(engine, false);
ok(!store.itemExists("readinglist"), "Should not apply Reading List root");
ok(!store.itemExists(listBmk.id), "Should not apply items in Reading List");
ok(store.itemExists(newBmk.id), "Should apply new bookmark");
ok(!(await store.itemExists("readinglist")), "Should not apply Reading List root");
ok(!(await store.itemExists(listBmk.id)), "Should not apply items in Reading List");
ok((await store.itemExists(newBmk.id)), "Should apply new bookmark");
deepEqual(collection.keys().sort(), ["menu", "mobile", "toolbar", "unfiled", newBmk.id].sort(),
"Should remove Places root and reading list items from server; upload local roots");
} finally {
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await promiseStopServer(server);
@ -124,6 +126,7 @@ add_task(async function test_processIncoming_error_orderChildren() {
_("Ensure that _orderChildren() is called even when _processIncoming() throws an error.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -134,7 +137,7 @@ add_task(async function test_processIncoming_error_orderChildren() {
let folder1_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder 1", 0);
let folder1_guid = store.GUIDForId(folder1_id);
let folder1_guid = await store.GUIDForId(folder1_id);
let fxuri = Utils.makeURI("http://getfirefox.com/");
let tburi = Utils.makeURI("http://getthunderbird.com/");
@ -146,7 +149,8 @@ add_task(async function test_processIncoming_error_orderChildren() {
// Create a server record for folder1 where we flip the order of
// the children.
let folder1_payload = store.createRecord(folder1_guid).cleartext;
let folder1_record = await store.createRecord(folder1_guid);
let folder1_payload = folder1_record.cleartext;
folder1_payload.children.reverse();
collection.insert(folder1_guid, encryptPayload(folder1_payload));
@ -172,7 +176,8 @@ add_task(async function test_processIncoming_error_orderChildren() {
ok(!!error);
// Verify that the bookmark order has been applied.
let new_children = store.createRecord(folder1_guid).children;
folder1_record = await store.createRecord(folder1_guid);
let new_children = folder1_record.children;
do_check_eq(new_children.length, 2);
do_check_eq(new_children[0], folder1_payload.children[0]);
do_check_eq(new_children[1], folder1_payload.children[1]);
@ -181,7 +186,7 @@ add_task(async function test_processIncoming_error_orderChildren() {
do_check_eq(PlacesUtils.bookmarks.getItemIndex(bmk2_id), 0);
} finally {
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await PlacesSyncUtils.bookmarks.reset();
@ -192,6 +197,7 @@ add_task(async function test_processIncoming_error_orderChildren() {
add_task(async function test_restorePromptsReupload() {
_("Ensure that restoring from a backup will reupload all records.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -204,7 +210,7 @@ add_task(async function test_restorePromptsReupload() {
let folder1_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder 1", 0);
let folder1_guid = store.GUIDForId(folder1_id);
let folder1_guid = await store.GUIDForId(folder1_id);
_("Folder 1: " + folder1_id + ", " + folder1_guid);
let fxuri = Utils.makeURI("http://getfirefox.com/");
@ -213,7 +219,7 @@ add_task(async function test_restorePromptsReupload() {
_("Create a single record.");
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
folder1_id, fxuri, PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
_("Get Firefox!: " + bmk1_id + ", " + bmk1_guid);
@ -231,7 +237,7 @@ add_task(async function test_restorePromptsReupload() {
_("Create a different record and sync.");
let bmk2_id = PlacesUtils.bookmarks.insertBookmark(
folder1_id, tburi, PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Thunderbird!");
let bmk2_guid = store.GUIDForId(bmk2_id);
let bmk2_guid = await store.GUIDForId(bmk2_id);
_("Get Thunderbird!: " + bmk2_id + ", " + bmk2_guid);
PlacesUtils.bookmarks.removeItem(bmk1_id);
@ -264,7 +270,7 @@ add_task(async function test_restorePromptsReupload() {
let newFX;
for (let guid of guids) {
count++;
let id = store.idForGUID(guid, true);
let id = await store.idForGUID(guid, true);
// Only one bookmark, so _all_ should be Firefox!
if (PlacesUtils.bookmarks.getItemType(id) == PlacesUtils.bookmarks.TYPE_BOOKMARK) {
let uri = PlacesUtils.bookmarks.getBookmarkURI(id);
@ -313,7 +319,7 @@ add_task(async function test_restorePromptsReupload() {
do_check_eq(folderWBOs[0].title, "Folder 1");
} finally {
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await PlacesSyncUtils.bookmarks.reset();
@ -362,11 +368,12 @@ add_task(async function test_mismatched_types() {
newRecord.cleartext = newRecord;
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
_("GUID: " + store.GUIDForId(6, true));
_("GUID: " + (await store.GUIDForId(6, true)));
try {
let bms = PlacesUtils.bookmarks;
@ -375,16 +382,16 @@ add_task(async function test_mismatched_types() {
oldR.parentid = PlacesUtils.bookmarks.toolbarGuid;
newR.parentid = PlacesUtils.bookmarks.toolbarGuid;
store.applyIncoming(oldR);
await store.applyIncoming(oldR);
_("Applied old. It's a folder.");
let oldID = store.idForGUID(oldR.id);
let oldID = await store.idForGUID(oldR.id);
_("Old ID: " + oldID);
do_check_eq(bms.getItemType(oldID), bms.TYPE_FOLDER);
do_check_false(PlacesUtils.annotations
.itemHasAnnotation(oldID, PlacesUtils.LMANNO_FEEDURI));
store.applyIncoming(newR);
let newID = store.idForGUID(newR.id);
await store.applyIncoming(newR);
let newID = await store.idForGUID(newR.id);
_("New ID: " + newID);
_("Applied new. It's a livemark.");
@ -393,7 +400,7 @@ add_task(async function test_mismatched_types() {
.itemHasAnnotation(newID, PlacesUtils.LMANNO_FEEDURI));
} finally {
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await PlacesSyncUtils.bookmarks.reset();
@ -405,6 +412,7 @@ add_task(async function test_bookmark_guidMap_fail() {
_("Ensure that failures building the GUID map cause early death.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
@ -414,8 +422,9 @@ add_task(async function test_bookmark_guidMap_fail() {
// Add one item to the server.
let itemID = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder 1", 0);
let itemGUID = store.GUIDForId(itemID);
let itemPayload = store.createRecord(itemGUID).cleartext;
let itemGUID = await store.GUIDForId(itemID);
let itemRecord = await store.createRecord(itemGUID);
let itemPayload = itemRecord.cleartext;
coll.insert(itemGUID, encryptPayload(itemPayload));
engine.lastSync = 1; // So we don't back up.
@ -425,15 +434,14 @@ add_task(async function test_bookmark_guidMap_fail() {
let pbt = PlacesUtils.promiseBookmarksTree;
PlacesUtils.promiseBookmarksTree = function() { return Promise.reject("Nooo"); };
// Ensure that we throw when accessing _guidMap.
engine._syncStartup();
// Ensure that we throw when calling getGuidMap().
await engine._syncStartup();
_("No error.");
do_check_false(engine._guidMapFailed);
_("We get an error if building _guidMap fails in use.");
let err;
try {
_(engine._guidMap);
_(await engine.getGuidMap());
} catch (ex) {
err = ex;
}
@ -443,7 +451,7 @@ add_task(async function test_bookmark_guidMap_fail() {
_("We get an error and abort during processIncoming.");
err = undefined;
try {
engine._processIncoming();
await engine._processIncoming();
} catch (ex) {
err = ex;
}
@ -458,6 +466,7 @@ add_task(async function test_bookmark_tag_but_no_uri() {
_("Ensure that a bookmark record with tags, but no URI, doesn't throw an exception.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
// We're simply checking that no exception is thrown, so
@ -494,15 +503,16 @@ add_task(async function test_bookmark_tag_but_no_uri() {
type: "folder"
});
store.create(record);
await store.create(record);
record.tags = ["bar"];
store.update(record);
await store.update(record);
});
add_task(async function test_misreconciled_root() {
_("Ensure that we don't reconcile an arbitrary record with a root.");
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -511,15 +521,15 @@ add_task(async function test_misreconciled_root() {
store._log.trace = store._log.debug;
engine._log.trace = engine._log.debug;
engine._syncStartup();
await engine._syncStartup();
// Let's find out where the toolbar is right now.
let toolbarBefore = store.createRecord("toolbar", "bookmarks");
let toolbarIDBefore = store.idForGUID("toolbar");
let toolbarBefore = await store.createRecord("toolbar", "bookmarks");
let toolbarIDBefore = await store.idForGUID("toolbar");
do_check_neq(-1, toolbarIDBefore);
let parentGUIDBefore = toolbarBefore.parentid;
let parentIDBefore = store.idForGUID(parentGUIDBefore);
let parentIDBefore = await store.idForGUID(parentGUIDBefore);
do_check_neq(-1, parentIDBefore);
do_check_eq("string", typeof(parentGUIDBefore));
@ -543,10 +553,10 @@ add_task(async function test_misreconciled_root() {
// Ensure that afterwards, toolbar is still there.
// As of 2012-12-05, this only passes because Places doesn't use "toolbar" as
// the real GUID, instead using a generated one. Sync does the translation.
let toolbarAfter = store.createRecord("toolbar", "bookmarks");
let toolbarAfter = await store.createRecord("toolbar", "bookmarks");
let parentGUIDAfter = toolbarAfter.parentid;
let parentIDAfter = store.idForGUID(parentGUIDAfter);
do_check_eq(store.GUIDForId(toolbarIDBefore), "toolbar");
let parentIDAfter = await store.idForGUID(parentGUIDAfter);
do_check_eq((await store.GUIDForId(toolbarIDBefore)), "toolbar");
do_check_eq(parentGUIDBefore, parentGUIDAfter);
do_check_eq(parentIDBefore, parentIDAfter);
@ -559,6 +569,7 @@ add_task(async function test_sync_dateAdded() {
await Service.recordManager.clearCache();
await PlacesSyncUtils.bookmarks.reset();
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -634,8 +645,8 @@ add_task(async function test_sync_dateAdded() {
collection.insert(item6GUID, encryptPayload(item6.cleartext), item6LastModified);
let origBuildWeakReuploadMap = engine.buildWeakReuploadMap;
engine.buildWeakReuploadMap = set => {
let fullMap = origBuildWeakReuploadMap.call(engine, set);
engine.buildWeakReuploadMap = async (set) => {
let fullMap = await origBuildWeakReuploadMap.call(engine, set);
fullMap.delete(item6GUID);
return fullMap;
};
@ -710,7 +721,7 @@ add_task(async function test_sync_dateAdded() {
} finally {
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await PlacesSyncUtils.bookmarks.reset();

23
services/sync/tests/unit/test_bookmark_invalid.js
Просмотреть файл

@ -4,11 +4,17 @@ Cu.import("resource://services-sync/engines/bookmarks.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Service.engineManager.register(BookmarksEngine);
let engine;
let store;
let tracker;
var engine = Service.engineManager.get("bookmarks");
var store = engine._store;
var tracker = engine._tracker;
add_task(async function setup() {
initTestLogging("Trace");
await Service.engineManager.register(BookmarksEngine);
engine = Service.engineManager.get("bookmarks");
store = engine._store;
tracker = engine._tracker;
});
add_task(async function test_ignore_invalid_uri() {
_("Ensure that we don't die with invalid bookmarks.");
@ -30,7 +36,7 @@ add_task(async function test_ignore_invalid_uri() {
// Ensure that this doesn't throw even though the DB is now in a bad state (a
// bookmark has an illegal url).
engine._buildGUIDMap();
await engine._buildGUIDMap();
});
add_task(async function test_ignore_missing_uri() {
@ -52,10 +58,5 @@ add_task(async function test_ignore_missing_uri() {
// Ensure that this doesn't throw even though the DB is now in a bad state (a
// bookmark has an illegal url).
engine._buildGUIDMap();
await engine._buildGUIDMap();
});
function run_test() {
initTestLogging("Trace");
run_next_test();
}

54
services/sync/tests/unit/test_bookmark_livemarks.js
Просмотреть файл

@ -11,11 +11,11 @@ Cu.import("resource://testing-common/services/common/utils.js");
const DESCRIPTION_ANNO = "bookmarkProperties/description";
var engine = Service.engineManager.get("bookmarks");
var store = engine._store;
let engine;
let store;
// Record borrowed from Bug 631361.
var record631361 = {
const record631361 = {
id: "M5bwUKK8hPyF",
index: 150,
modified: 1296768176.49,
@ -52,9 +52,6 @@ var record631361 = {
collection: "bookmarks"
};
// Clean up after other tests. Only necessary in XULRunner.
store.wipe();
function makeLivemark(p, mintGUID) {
let b = new Livemark("bookmarks", p.id);
// Copy here, because tests mutate the contents.
@ -66,50 +63,48 @@ function makeLivemark(p, mintGUID) {
return b;
}
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Store.Bookmarks").level = Log.Level.Trace;
run_next_test();
}
engine = Service.engineManager.get("bookmarks");
store = engine._store;
});
add_test(function test_livemark_descriptions() {
add_task(async function test_livemark_descriptions() {
let record = record631361.payload;
function doRecord(r) {
async function doRecord(r) {
store._childrenToOrder = {};
store.applyIncoming(r);
store._orderChildren();
await store.applyIncoming(r);
await store._orderChildren();
delete store._childrenToOrder;
}
// Attempt to provoke an error by messing around with the description.
record.description = null;
doRecord(makeLivemark(record));
await doRecord(makeLivemark(record));
record.description = "";
doRecord(makeLivemark(record));
await doRecord(makeLivemark(record));
// Attempt to provoke an error by adding a bad description anno.
let id = store.idForGUID(record.id);
let id = await store.idForGUID(record.id);
PlacesUtils.annotations.setItemAnnotation(id, DESCRIPTION_ANNO, "", 0,
PlacesUtils.annotations.EXPIRE_NEVER);
run_next_test();
});
add_test(function test_livemark_invalid() {
add_task(async function test_livemark_invalid() {
_("Livemarks considered invalid by nsLivemarkService are skipped.");
_("Parent is unknown. Will be set to unfiled.");
let lateParentRec = makeLivemark(record631361.payload, true);
let parentGUID = Utils.makeGUID();
lateParentRec.parentid = parentGUID;
do_check_eq(-1, store.idForGUID(parentGUID));
do_check_eq(-1, (await store.idForGUID(parentGUID)));
store.create(lateParentRec);
let recID = store.idForGUID(lateParentRec.id, true);
await store.create(lateParentRec);
let recID = await store.idForGUID(lateParentRec.id, true);
do_check_true(recID > 0);
do_check_eq(PlacesUtils.bookmarks.getFolderIdForItem(recID),
PlacesUtils.bookmarks.unfiledBookmarksFolder);
@ -117,17 +112,14 @@ add_test(function test_livemark_invalid() {
_("No feed URI, which is invalid. Will be skipped.");
let noFeedURIRec = makeLivemark(record631361.payload, true);
delete noFeedURIRec.cleartext.feedUri;
store.create(noFeedURIRec);
await store.create(noFeedURIRec);
// No exception, but no creation occurs.
do_check_eq(-1, store.idForGUID(noFeedURIRec.id, true));
do_check_eq(-1, (await store.idForGUID(noFeedURIRec.id, true)));
_("Parent is a Livemark. Will be skipped.");
let lmParentRec = makeLivemark(record631361.payload, true);
lmParentRec.parentid = store.GUIDForId(recID);
store.create(lmParentRec);
lmParentRec.parentid = await store.GUIDForId(recID);
await store.create(lmParentRec);
// No exception, but no creation occurs.
do_check_eq(-1, store.idForGUID(lmParentRec.id, true));
// Clear event loop.
Utils.nextTick(run_next_test);
do_check_eq(-1, (await store.idForGUID(lmParentRec.id, true)));
});

22
services/sync/tests/unit/test_bookmark_order.js
Просмотреть файл

@ -9,13 +9,9 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
function run_test() {
Svc.Prefs.set("log.logger.engine.bookmarks", "Trace");
initTestLogging("Trace");
Log.repository.getLogger("Sqlite").level = Log.Level.Info;
run_next_test();
}
Svc.Prefs.set("log.logger.engine.bookmarks", "Trace");
initTestLogging("Trace");
Log.repository.getLogger("Sqlite").level = Log.Level.Info;
function serverForFoo(engine) {
generateNewKeys(Service.collectionKeys);
@ -190,8 +186,8 @@ add_task(async function test_local_order_newer() {
index: 2,
}], "Should use local order as base if remote is older");
} finally {
engine.wipeClient();
Service.startOver();
await engine.wipeClient();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -235,8 +231,8 @@ add_task(async function test_remote_order_newer() {
index: 2,
}], "Should use remote order as base if local is older");
} finally {
engine.wipeClient();
Service.startOver();
await engine.wipeClient();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -246,7 +242,7 @@ add_task(async function test_bookmark_order() {
let store = engine._store;
_("Starting with a clean slate of no bookmarks");
store.wipe();
await store.wipe();
await assertBookmarksTreeMatches("", [{
guid: PlacesUtils.bookmarks.menuGuid,
index: 0,
@ -284,7 +280,7 @@ add_task(async function test_bookmark_order() {
async function apply(record) {
store._childrenToOrder = {};
store.applyIncoming(record);
await store.applyIncoming(record);
await store._orderChildren();
delete store._childrenToOrder;
}

16
services/sync/tests/unit/test_bookmark_places_query_rewriting.js
Просмотреть файл

@ -6,8 +6,8 @@ Cu.import("resource://services-sync/engines/bookmarks.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
var engine = new BookmarksEngine(Service);
var store = engine._store;
let engine = new BookmarksEngine(Service);
let store = engine._store;
function makeTagRecord(id, uri) {
let tagRecord = new BookmarkQuery("bookmarks", id);
@ -20,7 +20,7 @@ function makeTagRecord(id, uri) {
return tagRecord;
}
function run_test() {
add_task(async function run_test() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Store.Bookmarks").level = Log.Level.Trace;
@ -30,7 +30,7 @@ function run_test() {
_("Type: " + tagRecord.type);
_("Folder name: " + tagRecord.folderName);
store.applyIncoming(tagRecord);
await store.applyIncoming(tagRecord);
let tags = PlacesUtils.getFolderContents(PlacesUtils.tagsFolderId).root;
let tagID;
@ -46,14 +46,14 @@ function run_test() {
}
_("Tag ID: " + tagID);
let insertedRecord = store.createRecord("abcdefabcdef", "bookmarks");
let insertedRecord = await store.createRecord("abcdefabcdef", "bookmarks");
do_check_eq(insertedRecord.bmkUri, uri.replace("499", tagID));
_("... but not if the type is wrong.");
let wrongTypeURI = "place:folder=499&type=2&queryType=1";
let wrongTypeRecord = makeTagRecord("fedcbafedcba", wrongTypeURI);
store.applyIncoming(wrongTypeRecord);
await store.applyIncoming(wrongTypeRecord);
insertedRecord = store.createRecord("fedcbafedcba", "bookmarks");
insertedRecord = await store.createRecord("fedcbafedcba", "bookmarks");
do_check_eq(insertedRecord.bmkUri, wrongTypeURI);
}
});

93
services/sync/tests/unit/test_bookmark_repair.js
Просмотреть файл

@ -13,6 +13,11 @@ Cu.import("resource://services-sync/engines/clients.js");
Cu.import("resource://services-sync/engines/bookmarks.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace
Log.repository.getLogger("Sync.Engine.Clients").level = Log.Level.Trace
Log.repository.getLogger("Sqlite").level = Log.Level.Info; // less noisy
const LAST_BOOKMARK_SYNC_PREFS = [
"bookmarks.lastSync",
"bookmarks.lastSyncLocal",
@ -27,20 +32,20 @@ const BOOKMARK_REPAIR_STATE_PREFS = [
),
];
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace
Log.repository.getLogger("Sync.Engine.Clients").level = Log.Level.Trace
Log.repository.getLogger("Sqlite").level = Log.Level.Info; // less noisy
let clientsEngine = Service.clientsEngine;
let bookmarksEngine = Service.engineManager.get("bookmarks");
generateNewKeys(Service.collectionKeys);
let clientsEngine;
let bookmarksEngine;
var recordedEvents = [];
Service.recordTelemetryEvent = (object, method, value, extra = undefined) => {
recordedEvents.push({ object, method, value, extra });
};
add_task(async function setup() {
clientsEngine = Service.clientsEngine;
bookmarksEngine = Service.engineManager.get("bookmarks");
generateNewKeys(Service.collectionKeys);
Service.recordTelemetryEvent = (object, method, value, extra = undefined) => {
recordedEvents.push({ object, method, value, extra });
};
});
function checkRecordedEvents(expected, message) {
deepEqual(recordedEvents, expected, message);
@ -76,8 +81,8 @@ async function promiseValidationDone(expected) {
}
async function cleanup(server) {
bookmarksEngine._store.wipe();
clientsEngine._store.wipe();
await bookmarksEngine._store.wipe();
await clientsEngine._store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await promiseStopServer(server);
@ -98,7 +103,7 @@ add_task(async function test_bookmark_repair_integration() {
try {
_("Syncing to initialize crypto etc.");
Service.sync();
await Service.sync();
_("Create remote client record");
server.insertWBO("foo", "clients", new ServerWBO(remoteID, encryptPayload({
@ -124,7 +129,7 @@ add_task(async function test_bookmark_repair_integration() {
_(`Upload ${folderInfo.guid} and ${bookmarkInfo.guid} to server`);
let validationPromise = promiseValidationDone([]);
Service.sync();
await Service.sync();
equal(clientsEngine.stats.numClients, 2, "Clients collection should have 2 records");
await validationPromise;
checkRecordedEvents([], "Should not start repair after first sync");
@ -140,7 +145,7 @@ add_task(async function test_bookmark_repair_integration() {
await PlacesUtils.bookmarks.remove(bookmarkInfo.guid, {
source: PlacesUtils.bookmarks.SOURCE_SYNC,
});
deepEqual(bookmarksEngine.pullNewChanges(), {},
deepEqual((await bookmarksEngine.pullNewChanges()), {},
`Should not upload tombstone for ${bookmarkInfo.guid}`);
// sync again - we should have a few problems...
@ -149,7 +154,7 @@ add_task(async function test_bookmark_repair_integration() {
{"name": "missingChildren", "count": 1},
{"name": "structuralDifferences", "count": 1},
]);
Service.sync();
await Service.sync();
await validationPromise;
let flowID = Svc.Prefs.get("repairs.bookmarks.flowID");
checkRecordedEvents([{
@ -180,11 +185,11 @@ add_task(async function test_bookmark_repair_integration() {
}], "Should record telemetry events for repair request");
// We should have started a repair with our second client.
equal(clientsEngine.getClientCommands(remoteID).length, 1,
equal((await clientsEngine.getClientCommands(remoteID)).length, 1,
"Should queue repair request for remote client after repair");
_("Sync to send outgoing repair request");
Service.sync();
equal(clientsEngine.getClientCommands(remoteID).length, 0,
await Service.sync();
equal((await clientsEngine.getClientCommands(remoteID)).length, 0,
"Should send repair request to remote client after next sync");
checkRecordedEvents([],
"Should not record repair telemetry after sending repair request");
@ -195,6 +200,7 @@ add_task(async function test_bookmark_repair_integration() {
// so now let's take over the role of that other client!
_("Create new clients engine pretending to be remote client");
let remoteClientsEngine = Service.clientsEngine = new ClientEngine(Service);
await remoteClientsEngine.initialize();
remoteClientsEngine.localID = remoteID;
_("Restore missing bookmark");
@ -205,7 +211,7 @@ add_task(async function test_bookmark_repair_integration() {
restoreRemoteLastBookmarkSync();
_("Sync as remote client");
Service.sync();
await Service.sync();
checkRecordedEvents([{
object: "processcommand",
method: "repairRequest",
@ -240,14 +246,14 @@ add_task(async function test_bookmark_repair_integration() {
}], "Should record telemetry events for repair response");
// We should queue the repair response for the initial client.
equal(remoteClientsEngine.getClientCommands(initialID).length, 1,
equal((await remoteClientsEngine.getClientCommands(initialID)).length, 1,
"Should queue repair response for initial client after repair");
ok(user.collection("bookmarks").wbo(bookmarkInfo.guid),
"Should upload missing bookmark");
_("Sync to upload bookmark and send outgoing repair response");
Service.sync();
equal(remoteClientsEngine.getClientCommands(initialID).length, 0,
await Service.sync();
equal((await remoteClientsEngine.getClientCommands(initialID)).length, 0,
"Should send repair response to initial client after next sync");
checkRecordedEvents([],
"Should not record repair telemetry after sending repair response");
@ -267,7 +273,7 @@ add_task(async function test_bookmark_repair_integration() {
_("Sync as initial client");
let revalidationPromise = promiseValidationDone([]);
Service.sync();
await Service.sync();
let restoredBookmarkInfo = await PlacesUtils.bookmarks.fetch(bookmarkInfo.guid);
ok(restoredBookmarkInfo, "Missing bookmark should be downloaded to initial client");
checkRecordedEvents([{
@ -301,6 +307,7 @@ add_task(async function test_bookmark_repair_integration() {
} finally {
await cleanup(server);
clientsEngine = Service.clientsEngine = new ClientEngine(Service);
clientsEngine.initialize();
}
});
@ -316,7 +323,7 @@ add_task(async function test_repair_client_missing() {
try {
_("Syncing to initialize crypto etc.");
Service.sync();
await Service.sync();
_("Create remote client record");
server.insertWBO("foo", "clients", new ServerWBO(remoteID, encryptPayload({
@ -336,7 +343,7 @@ add_task(async function test_repair_client_missing() {
let validationPromise = promiseValidationDone([]);
_("Syncing.");
Service.sync();
await Service.sync();
// should have 2 clients
equal(clientsEngine.stats.numClients, 2)
await validationPromise;
@ -347,7 +354,7 @@ add_task(async function test_repair_client_missing() {
source: PlacesUtils.bookmarks.SOURCE_SYNC,
});
// sanity check we aren't going to sync this removal.
do_check_empty(bookmarksEngine.pullNewChanges());
do_check_empty((await bookmarksEngine.pullNewChanges()));
// sanity check that the bookmark is not there anymore
do_check_false(await PlacesUtils.bookmarks.fetch(bookmarkInfo.guid));
@ -357,14 +364,14 @@ add_task(async function test_repair_client_missing() {
{"name": "clientMissing", "count": 1},
{"name": "structuralDifferences", "count": 1},
]);
Service.sync();
await Service.sync();
await validationPromise;
// We shouldn't have started a repair with our second client.
equal(clientsEngine.getClientCommands(remoteID).length, 0);
equal((await clientsEngine.getClientCommands(remoteID)).length, 0);
// Trigger a sync (will request the missing item)
Service.sync();
await Service.sync();
// And we got our bookmark back
do_check_true(await PlacesUtils.bookmarks.fetch(bookmarkInfo.guid));
@ -387,7 +394,7 @@ add_task(async function test_repair_server_missing() {
try {
_("Syncing to initialize crypto etc.");
Service.sync();
await Service.sync();
_("Create remote client record");
server.insertWBO("foo", "clients", new ServerWBO(remoteID, encryptPayload({
@ -407,7 +414,7 @@ add_task(async function test_repair_server_missing() {
let validationPromise = promiseValidationDone([]);
_("Syncing.");
Service.sync();
await Service.sync();
// should have 2 clients
equal(clientsEngine.stats.numClients, 2)
await validationPromise;
@ -421,14 +428,14 @@ add_task(async function test_repair_server_missing() {
{"name": "serverMissing", "count": 1},
{"name": "missingChildren", "count": 1},
]);
Service.sync();
await Service.sync();
await validationPromise;
// We shouldn't have started a repair with our second client.
equal(clientsEngine.getClientCommands(remoteID).length, 0);
equal((await clientsEngine.getClientCommands(remoteID)).length, 0);
// Trigger a sync (will upload the missing item)
Service.sync();
await Service.sync();
// And the server got our bookmark back
do_check_true(user.collection("bookmarks").wbo(bookmarkInfo.guid));
@ -449,7 +456,7 @@ add_task(async function test_repair_server_deleted() {
try {
_("Syncing to initialize crypto etc.");
Service.sync();
await Service.sync();
_("Create remote client record");
server.insertWBO("foo", "clients", new ServerWBO(remoteID, encryptPayload({
@ -469,7 +476,7 @@ add_task(async function test_repair_server_deleted() {
let validationPromise = promiseValidationDone([]);
_("Syncing.");
Service.sync();
await Service.sync();
// should have 2 clients
equal(clientsEngine.stats.numClients, 2)
await validationPromise;
@ -487,14 +494,14 @@ add_task(async function test_repair_server_deleted() {
{"name": "deletedChildren", "count": 1},
{"name": "orphans", "count": 1}
]);
Service.sync();
await Service.sync();
await validationPromise;
// We shouldn't have started a repair with our second client.
equal(clientsEngine.getClientCommands(remoteID).length, 0);
equal((await clientsEngine.getClientCommands(remoteID)).length, 0);
// Trigger a sync (will upload the missing item)
Service.sync();
await Service.sync();
// And the client deleted our bookmark
do_check_true(!(await PlacesUtils.bookmarks.fetch(bookmarkInfo.guid)));

38
services/sync/tests/unit/test_bookmark_repair_requestor.js
Просмотреть файл

@ -28,13 +28,13 @@ class MockClientsEngine {
return this._clientList[id];
}
sendCommand(command, args, clientID) {
async sendCommand(command, args, clientID) {
let cc = this._sentCommands[clientID] || [];
cc.push({ command, args });
this._sentCommands[clientID] = cc;
}
getClientCommands(clientID) {
async getClientCommands(clientID) {
return this._sentCommands[clientID] || [];
}
}
@ -98,7 +98,7 @@ add_task(async function test_requestor_no_clients() {
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// there are no clients, so we should end up in "finished" (which we need to
// check via telemetry)
deepEqual(mockService._recordedEvents, [
@ -129,26 +129,26 @@ add_task(async function test_requestor_one_client_no_response() {
}
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// the command should now be outgoing.
checkOutgoingCommand(mockService, "client-a");
checkState(BookmarkRepairRequestor.STATE.SENT_REQUEST);
// asking it to continue stays in that state until we timeout or the command
// is removed.
requestor.continueRepairs();
await requestor.continueRepairs();
checkState(BookmarkRepairRequestor.STATE.SENT_REQUEST);
// now pretend that client synced.
mockService.clientsEngine._sentCommands = {};
requestor.continueRepairs();
await requestor.continueRepairs();
checkState(BookmarkRepairRequestor.STATE.SENT_SECOND_REQUEST);
// the command should be outgoing again.
checkOutgoingCommand(mockService, "client-a");
// pretend that client synced again without writing a command.
mockService.clientsEngine._sentCommands = {};
requestor.continueRepairs();
await requestor.continueRepairs();
// There are no more clients, so we've given up.
checkRepairFinished();
@ -190,7 +190,7 @@ add_task(async function test_requestor_one_client_no_sync() {
}
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// the command should now be outgoing.
checkOutgoingCommand(mockService, "client-a");
@ -200,7 +200,7 @@ add_task(async function test_requestor_one_client_no_sync() {
let theFuture = Date.now() + 300000000;
requestor._now = () => theFuture;
requestor.continueRepairs();
await requestor.continueRepairs();
// We should be finished as we gave up in disgust.
checkRepairFinished();
@ -242,7 +242,7 @@ add_task(async function test_requestor_latest_client_used() {
orphans: [],
}
}
requestor.startRepairs(validationInfo, Utils.makeGUID());
await requestor.startRepairs(validationInfo, Utils.makeGUID());
// the repair command should be outgoing to the most-recent client.
checkOutgoingCommand(mockService, "client-late");
checkState(BookmarkRepairRequestor.STATE.SENT_REQUEST);
@ -267,7 +267,7 @@ add_task(async function test_requestor_client_vanishes() {
}
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// the command should now be outgoing.
checkOutgoingCommand(mockService, "client-a");
@ -277,7 +277,7 @@ add_task(async function test_requestor_client_vanishes() {
// Now let's pretend the client vanished.
delete mockService.clientsEngine._clientList["client-a"];
requestor.continueRepairs();
await requestor.continueRepairs();
// We should have moved on to client-b.
checkState(BookmarkRepairRequestor.STATE.SENT_REQUEST);
checkOutgoingCommand(mockService, "client-b");
@ -290,7 +290,7 @@ add_task(async function test_requestor_client_vanishes() {
clientID: "client-b",
ids: ["a", "b", "c"],
}
requestor.continueRepairs(response);
await requestor.continueRepairs(response);
// We should be finished as we got all our IDs.
checkRepairFinished();
@ -345,7 +345,7 @@ add_task(async function test_requestor_success_responses() {
}
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// the command should now be outgoing.
checkOutgoingCommand(mockService, "client-a");
@ -360,7 +360,7 @@ add_task(async function test_requestor_success_responses() {
flowID: requestor._flowID,
ids: ["a", "b"],
}
requestor.continueRepairs(response);
await requestor.continueRepairs(response);
// We should have moved on to client 2.
checkState(BookmarkRepairRequestor.STATE.SENT_REQUEST);
checkOutgoingCommand(mockService, "client-b");
@ -373,7 +373,7 @@ add_task(async function test_requestor_success_responses() {
flowID: requestor._flowID,
ids: ["c"],
}
requestor.continueRepairs(response);
await requestor.continueRepairs(response);
// We should be finished as we got all our IDs.
checkRepairFinished();
@ -441,7 +441,7 @@ add_task(async function test_requestor_already_repairing_at_start() {
}
let flowID = Utils.makeGUID();
ok(!requestor.startRepairs(validationInfo, flowID),
ok(!(await requestor.startRepairs(validationInfo, flowID)),
"Shouldn't start repairs");
equal(mockService._recordedEvents.length, 1);
equal(mockService._recordedEvents[0].method, "aborted");
@ -465,7 +465,7 @@ add_task(async function test_requestor_already_repairing_continue() {
}
}
let flowID = Utils.makeGUID();
requestor.startRepairs(validationInfo, flowID);
await requestor.startRepairs(validationInfo, flowID);
// the command should now be outgoing.
checkOutgoingCommand(mockService, "client-a");
@ -488,7 +488,7 @@ add_task(async function test_requestor_already_repairing_continue() {
}];
requestor.continueRepairs(response);
await requestor.continueRepairs(response);
// We should have aborted now
checkRepairFinished();

75
services/sync/tests/unit/test_bookmark_repair_responder.js
Просмотреть файл

@ -16,11 +16,12 @@ Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace;
// sqlite logging generates lots of noise and typically isn't helpful here.
Log.repository.getLogger("Sqlite").level = Log.Level.Error;
// Disable validation so that we don't try to automatically repair the server
// when we sync.
Svc.Prefs.set("engine.bookmarks.validation.enabled", false);
// stub telemetry so we can easily check the right things are recorded.
var recordedEvents = [];
Service.recordTelemetryEvent = (object, method, value, extra = undefined) => {
recordedEvents.push({ object, method, value, extra });
};
function checkRecordedEvents(expected) {
deepEqual(recordedEvents, expected);
@ -32,32 +33,34 @@ function getServerBookmarks(server) {
return server.user("foo").collection("bookmarks");
}
async function setup() {
let bookmarksEngine = Service.engineManager.get("bookmarks");
async function makeServer() {
let server = serverForFoo(bookmarksEngine);
await SyncTestingInfrastructure(server);
// Disable validation so that we don't try to automatically repair the server
// when we sync.
Svc.Prefs.set("engine.bookmarks.validation.enabled", false);
return server;
}
async function cleanup(server) {
await promiseStopServer(server);
await PlacesSyncUtils.bookmarks.wipe();
Svc.Prefs.reset("engine.bookmarks.validation.enabled");
// clear keys so when each test finds a different server it accepts its keys.
Service.collectionKeys.clear();
}
let bookmarksEngine;
add_task(async function setup() {
bookmarksEngine = Service.engineManager.get("bookmarks");
Service.recordTelemetryEvent = (object, method, value, extra = undefined) => {
recordedEvents.push({ object, method, value, extra });
};
});
add_task(async function test_responder_error() {
let server = await setup();
let server = await makeServer();
// sync so the collection is created.
Service.sync();
await Service.sync();
let request = {
request: "upload",
@ -86,10 +89,10 @@ add_task(async function test_responder_error() {
});
add_task(async function test_responder_no_items() {
let server = await setup();
let server = await makeServer();
// sync so the collection is created.
Service.sync();
await Service.sync();
let request = {
request: "upload",
@ -112,7 +115,7 @@ add_task(async function test_responder_no_items() {
// One item requested and we have it locally, but it's not yet on the server.
add_task(async function test_responder_upload() {
let server = await setup();
let server = await makeServer();
// Pretend we've already synced this bookmark, so that we can ensure it's
// uploaded in response to our repair request.
@ -121,7 +124,7 @@ add_task(async function test_responder_upload() {
url: "http://getfirefox.com/",
source: PlacesUtils.bookmarks.SOURCES.SYNC });
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), [
"menu",
"mobile",
@ -145,7 +148,7 @@ add_task(async function test_responder_upload() {
},
]);
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), [
"menu",
"mobile",
@ -168,14 +171,14 @@ add_task(async function test_responder_upload() {
// One item requested and we have it locally and it's already on the server.
// As it was explicitly requested, we should upload it.
add_task(async function test_responder_item_exists_locally() {
let server = await setup();
let server = await makeServer();
let bm = await PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid,
title: "Get Firefox",
url: "http://getfirefox.com/" });
// first sync to get the item on the server.
_("Syncing to get item on the server");
Service.sync();
await Service.sync();
// issue a repair request for it.
let request = {
@ -196,7 +199,7 @@ add_task(async function test_responder_item_exists_locally() {
]);
_("Syncing to do the upload.");
Service.sync();
await Service.sync();
checkRecordedEvents([
{ object: "repairResponse",
@ -209,7 +212,7 @@ add_task(async function test_responder_item_exists_locally() {
});
add_task(async function test_responder_tombstone() {
let server = await setup();
let server = await makeServer();
// TODO: Request an item for which we have a tombstone locally. Decide if
// we want to store tombstones permanently for this. In the integration
@ -221,7 +224,7 @@ add_task(async function test_responder_tombstone() {
});
add_task(async function test_responder_missing_items() {
let server = await setup();
let server = await makeServer();
let fxBmk = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
@ -236,7 +239,7 @@ add_task(async function test_responder_missing_items() {
source: PlacesUtils.bookmarks.SOURCES.SYNC,
});
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), [
"menu",
"mobile",
@ -263,7 +266,7 @@ add_task(async function test_responder_missing_items() {
]);
_("Sync after requesting IDs");
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), [
"menu",
"mobile",
@ -285,9 +288,9 @@ add_task(async function test_responder_missing_items() {
});
add_task(async function test_non_syncable() {
let server = await setup();
let server = await makeServer();
Service.sync(); // to create the collections on the server.
await Service.sync(); // to create the collections on the server.
// Creates the left pane queries as a side effect.
let leftPaneId = PlacesUIUtils.leftPaneFolderId;
@ -330,7 +333,7 @@ add_task(async function test_non_syncable() {
]);
_("Sync to upload tombstones for items");
Service.sync();
await Service.sync();
let toolbarQueryId = PlacesUIUtils.leftPaneQueries.BookmarksToolbar;
let menuQueryId = PlacesUIUtils.leftPaneQueries.BookmarksMenu;
@ -376,7 +379,7 @@ add_task(async function test_non_syncable() {
});
add_task(async function test_folder_descendants() {
let server = await setup();
let server = await makeServer();
let parentFolder = await PlacesUtils.bookmarks.insert({
type: PlacesUtils.bookmarks.TYPE_FOLDER,
@ -404,7 +407,7 @@ add_task(async function test_folder_descendants() {
});
_("Initial sync to upload roots and parent folder");
Service.sync();
await Service.sync();
let initialSyncIds = [
"menu",
@ -446,7 +449,7 @@ add_task(async function test_folder_descendants() {
});
_("Sync again; server contents shouldn't change");
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), initialSyncIds,
"Second sync should not upload missing bookmarks");
@ -479,7 +482,7 @@ add_task(async function test_folder_descendants() {
]);
_("Sync after requesting repair; should upload missing records");
Service.sync();
await Service.sync();
deepEqual(getServerBookmarks(server).keys().sort(), [
...initialSyncIds,
childBmk.syncId,
@ -500,7 +503,7 @@ add_task(async function test_folder_descendants() {
// Error handling.
add_task(async function test_aborts_unknown_request() {
let server = await setup();
let server = await makeServer();
let request = {
request: "not-upload",
@ -521,3 +524,7 @@ add_task(async function test_aborts_unknown_request() {
]);
await cleanup(server);
});
add_task(async function teardown() {
Svc.Prefs.reset("engine.bookmarks.validation.enabled");
});

54
services/sync/tests/unit/test_bookmark_smart_bookmarks.js
Просмотреть файл

@ -9,17 +9,8 @@ Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
const SMART_BOOKMARKS_ANNO = "Places/SmartBookmark";
var IOService = Cc["@mozilla.org/network/io-service;1"]
const IOService = Cc["@mozilla.org/network/io-service;1"]
.getService(Ci.nsIIOService);
("http://www.mozilla.com", null, null);
Service.engineManager.register(BookmarksEngine);
var engine = Service.engineManager.get("bookmarks");
var store = engine._store;
// Clean up after other tests. Only necessary in XULRunner.
store.wipe();
function newSmartBookmark(parent, uri, position, title, queryID) {
let id = PlacesUtils.bookmarks.insertBookmark(parent, uri, position, title);
@ -45,6 +36,15 @@ function clearBookmarks() {
PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.bookmarks.unfiledBookmarksFolder);
}
let engine;
let store;
add_task(async function setup() {
await Service.engineManager.register(BookmarksEngine);
engine = Service.engineManager.get("bookmarks");
store = engine._store;
});
// Verify that Places smart bookmarks have their annotation uploaded and
// handled locally.
add_task(async function test_annotation_uploaded() {
@ -79,12 +79,12 @@ add_task(async function test_annotation_uploaded() {
_("Anno: " + annoValue);
do_check_eq("MostVisited", annoValue);
let guid = store.GUIDForId(mostVisitedID);
let guid = await store.GUIDForId(mostVisitedID);
_("GUID: " + guid);
do_check_true(!!guid);
_("Create record object and verify that it's sane.");
let record = store.createRecord(guid);
let record = await store.createRecord(guid);
do_check_true(record instanceof Bookmark);
do_check_true(record instanceof BookmarkQuery);
@ -126,8 +126,8 @@ add_task(async function test_annotation_uploaded() {
mostVisitedID, Utils.makeURI("http://something/else"));
PlacesUtils.annotations.removeItemAnnotation(mostVisitedID,
SMART_BOOKMARKS_ANNO);
store.wipe();
engine.resetClient();
await store.wipe();
await engine.resetClient();
do_check_eq(smartBookmarkCount(), startCount);
_("Sync. Verify that the downloaded record carries the annotation.");
@ -138,24 +138,24 @@ add_task(async function test_annotation_uploaded() {
do_check_eq(smartBookmarkCount(), startCount + 1);
_("Find by GUID and verify that it's annotated.");
let newID = store.idForGUID(serverGUID);
let newID = await store.idForGUID(serverGUID);
let newAnnoValue = PlacesUtils.annotations.getItemAnnotation(
newID, SMART_BOOKMARKS_ANNO);
do_check_eq(newAnnoValue, "MostVisited");
do_check_eq(PlacesUtils.bookmarks.getBookmarkURI(newID).spec, uri.spec);
_("Test updating.");
let newRecord = store.createRecord(serverGUID);
let newRecord = await store.createRecord(serverGUID);
do_check_eq(newRecord.queryId, newAnnoValue);
newRecord.queryId = "LeastVisited";
store.update(newRecord);
await store.update(newRecord);
do_check_eq("LeastVisited", PlacesUtils.annotations.getItemAnnotation(
newID, SMART_BOOKMARKS_ANNO));
} finally {
// Clean up.
store.wipe();
await store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await promiseStopServer(server);
@ -173,19 +173,19 @@ add_task(async function test_smart_bookmarks_duped() {
"&maxResults=10");
let title = "Most Visited";
let mostVisitedID = newSmartBookmark(parent, uri, -1, title, "MostVisited");
let mostVisitedGUID = store.GUIDForId(mostVisitedID);
let mostVisitedGUID = await store.GUIDForId(mostVisitedID);
let record = store.createRecord(mostVisitedGUID);
let record = await store.createRecord(mostVisitedGUID);
_("Prepare sync.");
try {
engine._syncStartup();
await engine._syncStartup();
_("Verify that mapDupe uses the anno, discovering a dupe regardless of URI.");
do_check_eq(mostVisitedGUID, engine._mapDupe(record));
do_check_eq(mostVisitedGUID, (await engine._mapDupe(record)));
record.bmkUri = "http://foo/";
do_check_eq(mostVisitedGUID, engine._mapDupe(record));
do_check_eq(mostVisitedGUID, (await engine._mapDupe(record)));
do_check_neq(PlacesUtils.bookmarks.getBookmarkURI(mostVisitedID).spec,
record.bmkUri);
@ -195,18 +195,18 @@ add_task(async function test_smart_bookmarks_duped() {
other.parentName = "Bookmarks Toolbar";
other.bmkUri = "place:foo";
other.title = "";
do_check_eq(undefined, engine._findDupe(other));
do_check_eq(undefined, (await engine._findDupe(other)));
_("Handle records without a queryId entry.");
record.bmkUri = uri;
delete record.queryId;
do_check_eq(mostVisitedGUID, engine._mapDupe(record));
do_check_eq(mostVisitedGUID, (await engine._mapDupe(record)));
engine._syncFinish();
await engine._syncFinish();
} finally {
// Clean up.
store.wipe();
await store.wipe();
await promiseStopServer(server);
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();

185
services/sync/tests/unit/test_bookmark_store.js
Просмотреть файл

@ -8,17 +8,23 @@ Cu.import("resource://services-sync/util.js");
const PARENT_ANNO = "sync/parent";
Service.engineManager.register(BookmarksEngine);
let engine;
let store;
let tracker;
var engine = Service.engineManager.get("bookmarks");
var store = engine._store;
var tracker = engine._tracker;
const fxuri = Utils.makeURI("http://getfirefox.com/");
const tburi = Utils.makeURI("http://getthunderbird.com/");
// Don't write some persistence files asynchronously.
tracker.persistChangedIDs = false;
add_task(async function setup() {
await Service.engineManager.register(BookmarksEngine);
var fxuri = Utils.makeURI("http://getfirefox.com/");
var tburi = Utils.makeURI("http://getthunderbird.com/");
engine = Service.engineManager.get("bookmarks");
store = engine._store;
tracker = engine._tracker;
// Don't write some persistence files asynchronously.
tracker.persistChangedIDs = false;
});
add_task(async function test_ignore_specials() {
_("Ensure that we can't delete bookmark roots.");
@ -26,27 +32,27 @@ add_task(async function test_ignore_specials() {
// Belt...
let record = new BookmarkFolder("bookmarks", "toolbar", "folder");
record.deleted = true;
do_check_neq(null, store.idForGUID("toolbar"));
do_check_neq(null, (await store.idForGUID("toolbar")));
store.applyIncoming(record);
await store.applyIncoming(record);
await store.deletePending();
// Ensure that the toolbar exists.
do_check_neq(null, store.idForGUID("toolbar"));
do_check_neq(null, (await store.idForGUID("toolbar")));
// This will fail painfully in getItemType if the deletion worked.
engine._buildGUIDMap();
await engine._buildGUIDMap();
// Braces...
store.remove(record);
await store.remove(record);
await store.deletePending();
do_check_neq(null, store.idForGUID("toolbar"));
engine._buildGUIDMap();
do_check_neq(null, (await store.idForGUID("toolbar")));
await engine._buildGUIDMap();
store.wipe();
await store.wipe();
});
add_test(function test_bookmark_create() {
add_task(async function test_bookmark_create() {
try {
_("Ensure the record isn't present yet.");
let ids = PlacesUtils.bookmarks.getBookmarkIdsForURI(fxuri, {});
@ -62,11 +68,11 @@ add_test(function test_bookmark_create() {
fxrecord.loadInSidebar = false;
fxrecord.parentName = "Bookmarks Toolbar";
fxrecord.parentid = "toolbar";
store.applyIncoming(fxrecord);
await store.applyIncoming(fxrecord);
_("Verify it has been created correctly.");
let id = store.idForGUID(fxrecord.id);
do_check_eq(store.GUIDForId(id), fxrecord.id);
let id = await store.idForGUID(fxrecord.id);
do_check_eq((await store.GUIDForId(id)), fxrecord.id);
do_check_eq(PlacesUtils.bookmarks.getItemType(id),
PlacesUtils.bookmarks.TYPE_BOOKMARK);
do_check_true(PlacesUtils.bookmarks.getBookmarkURI(id).equals(fxuri));
@ -78,7 +84,7 @@ add_test(function test_bookmark_create() {
do_check_eq(PlacesUtils.bookmarks.getKeywordForBookmark(id), fxrecord.keyword);
_("Have the store create a new record object. Verify that it has the same data.");
let newrecord = store.createRecord(fxrecord.id);
let newrecord = await store.createRecord(fxrecord.id);
do_check_true(newrecord instanceof Bookmark);
for (let property of ["type", "bmkUri", "description", "title",
"keyword", "parentName", "parentid"]) {
@ -95,11 +101,11 @@ add_test(function test_bookmark_create() {
tbrecord.bmkUri = tburi.spec;
tbrecord.parentName = "Bookmarks Toolbar";
tbrecord.parentid = "toolbar";
store.applyIncoming(tbrecord);
await store.applyIncoming(tbrecord);
_("Verify it has been created correctly.");
id = store.idForGUID(tbrecord.id);
do_check_eq(store.GUIDForId(id), tbrecord.id);
id = await store.idForGUID(tbrecord.id);
do_check_eq((await store.GUIDForId(id)), tbrecord.id);
do_check_eq(PlacesUtils.bookmarks.getItemType(id),
PlacesUtils.bookmarks.TYPE_BOOKMARK);
do_check_true(PlacesUtils.bookmarks.getBookmarkURI(id).equals(tburi));
@ -116,12 +122,11 @@ add_test(function test_bookmark_create() {
do_check_eq(PlacesUtils.bookmarks.getKeywordForBookmark(id), null);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
add_test(function test_bookmark_update() {
add_task(async function test_bookmark_update() {
try {
_("Create a bookmark whose values we'll change.");
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
@ -132,15 +137,15 @@ add_test(function test_bookmark_update() {
bmk1_id, "bookmarkProperties/description", "Firefox is awesome.", 0,
PlacesUtils.annotations.EXPIRE_NEVER);
PlacesUtils.bookmarks.setKeywordForBookmark(bmk1_id, "firefox");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
_("Update the record with some null values.");
let record = store.createRecord(bmk1_guid);
let record = await store.createRecord(bmk1_guid);
record.title = null;
record.description = null;
record.keyword = null;
record.tags = null;
store.applyIncoming(record);
await store.applyIncoming(record);
_("Verify that the values have been cleared.");
do_check_throws(function() {
@ -151,43 +156,41 @@ add_test(function test_bookmark_update() {
do_check_eq(PlacesUtils.bookmarks.getKeywordForBookmark(bmk1_id), null);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
add_test(function test_bookmark_createRecord() {
add_task(async function test_bookmark_createRecord() {
try {
_("Create a bookmark without a description or title.");
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, fxuri,
PlacesUtils.bookmarks.DEFAULT_INDEX, null);
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
_("Verify that the record is created accordingly.");
let record = store.createRecord(bmk1_guid);
let record = await store.createRecord(bmk1_guid);
do_check_eq(record.title, "");
do_check_eq(record.description, null);
do_check_eq(record.keyword, null);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
add_test(function test_folder_create() {
add_task(async function test_folder_create() {
try {
_("Create a folder.");
let folder = new BookmarkFolder("bookmarks", "testfolder-1");
folder.parentName = "Bookmarks Toolbar";
folder.parentid = "toolbar";
folder.title = "Test Folder";
store.applyIncoming(folder);
await store.applyIncoming(folder);
_("Verify it has been created correctly.");
let id = store.idForGUID(folder.id);
let id = await store.idForGUID(folder.id);
do_check_eq(PlacesUtils.bookmarks.getItemType(id),
PlacesUtils.bookmarks.TYPE_FOLDER);
do_check_eq(PlacesUtils.bookmarks.getItemTitle(id), folder.title);
@ -195,7 +198,7 @@ add_test(function test_folder_create() {
PlacesUtils.bookmarks.toolbarFolder);
_("Have the store create a new record object. Verify that it has the same data.");
let newrecord = store.createRecord(folder.id);
let newrecord = await store.createRecord(folder.id);
do_check_true(newrecord instanceof BookmarkFolder);
for (let property of ["title", "parentName", "parentid"])
do_check_eq(newrecord[property], folder[property]);
@ -204,17 +207,16 @@ add_test(function test_folder_create() {
do_check_eq(newrecord.sortindex, 1000000);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
add_test(function test_folder_createRecord() {
add_task(async function test_folder_createRecord() {
try {
_("Create a folder.");
let folder1_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder1", 0);
let folder1_guid = store.GUIDForId(folder1_id);
let folder1_guid = await store.GUIDForId(folder1_id);
_("Create two bookmarks in that folder without assigning them GUIDs.");
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
@ -223,23 +225,22 @@ add_test(function test_folder_createRecord() {
folder1_id, tburi, PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Thunderbird!");
_("Create a record for the folder and verify basic properties.");
let record = store.createRecord(folder1_guid);
let record = await store.createRecord(folder1_guid);
do_check_true(record instanceof BookmarkFolder);
do_check_eq(record.title, "Folder1");
do_check_eq(record.parentid, "toolbar");
do_check_eq(record.parentName, "Bookmarks Toolbar");
_("Verify the folder's children. Ensures that the bookmarks were given GUIDs.");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk2_guid = store.GUIDForId(bmk2_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
let bmk2_guid = await store.GUIDForId(bmk2_id);
do_check_eq(record.children.length, 2);
do_check_eq(record.children[0], bmk1_guid);
do_check_eq(record.children[1], bmk2_guid);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
@ -249,12 +250,12 @@ add_task(async function test_deleted() {
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, fxuri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
_("Delete the bookmark through the store.");
let record = new PlacesItem("bookmarks", bmk1_guid);
record.deleted = true;
store.applyIncoming(record);
await store.applyIncoming(record);
await store.deletePending();
_("Ensure it has been deleted.");
let error;
@ -265,41 +266,40 @@ add_task(async function test_deleted() {
}
do_check_eq(error.result, Cr.NS_ERROR_ILLEGAL_VALUE);
let newrec = store.createRecord(bmk1_guid);
let newrec = await store.createRecord(bmk1_guid);
do_check_eq(newrec.deleted, true);
} finally {
_("Clean up.");
store.wipe();
await store.wipe();
}
});
add_test(function test_move_folder() {
add_task(async function test_move_folder() {
try {
_("Create two folders and a bookmark in one of them.");
let folder1_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder1", 0);
let folder1_guid = store.GUIDForId(folder1_id);
let folder1_guid = await store.GUIDForId(folder1_id);
let folder2_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder2", 0);
let folder2_guid = store.GUIDForId(folder2_id);
let folder2_guid = await store.GUIDForId(folder2_id);
let bmk_id = PlacesUtils.bookmarks.insertBookmark(
folder1_id, fxuri, PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bmk_guid = store.GUIDForId(bmk_id);
let bmk_guid = await store.GUIDForId(bmk_id);
_("Get a record, reparent it and apply it to the store.");
let record = store.createRecord(bmk_guid);
let record = await store.createRecord(bmk_guid);
do_check_eq(record.parentid, folder1_guid);
record.parentid = folder2_guid;
store.applyIncoming(record);
await store.applyIncoming(record);
_("Verify the new parent.");
let new_folder_id = PlacesUtils.bookmarks.getFolderIdForItem(bmk_id);
do_check_eq(store.GUIDForId(new_folder_id), folder2_guid);
do_check_eq((await store.GUIDForId(new_folder_id)), folder2_guid);
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
@ -311,16 +311,16 @@ add_task(async function test_move_order() {
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, fxuri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
let bmk2_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, tburi,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Thunderbird!");
let bmk2_guid = store.GUIDForId(bmk2_id);
let bmk2_guid = await store.GUIDForId(bmk2_id);
_("Verify order.");
do_check_eq(PlacesUtils.bookmarks.getItemIndex(bmk1_id), 0);
do_check_eq(PlacesUtils.bookmarks.getItemIndex(bmk2_id), 1);
let toolbar = store.createRecord("toolbar");
let toolbar = await store.createRecord("toolbar");
do_check_eq(toolbar.children.length, 2);
do_check_eq(toolbar.children[0], bmk1_guid);
do_check_eq(toolbar.children[1], bmk2_guid);
@ -328,7 +328,7 @@ add_task(async function test_move_order() {
_("Move bookmarks around.");
store._childrenToOrder = {};
toolbar.children = [bmk2_guid, bmk1_guid];
store.applyIncoming(toolbar);
await store.applyIncoming(toolbar);
// Bookmarks engine does this at the end of _processIncoming
tracker.ignoreAll = true;
await store._orderChildren();
@ -342,18 +342,18 @@ add_task(async function test_move_order() {
} finally {
Svc.Obs.notify("weave:engine:stop-tracking");
_("Clean up.");
store.wipe();
await store.wipe();
}
});
add_test(function test_orphan() {
add_task(async function test_orphan() {
try {
_("Add a new bookmark locally.");
let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, fxuri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bmk1_guid = store.GUIDForId(bmk1_id);
let bmk1_guid = await store.GUIDForId(bmk1_id);
do_check_eq(PlacesUtils.bookmarks.getFolderIdForItem(bmk1_id),
PlacesUtils.bookmarks.toolbarFolder);
let error;
@ -365,9 +365,9 @@ add_test(function test_orphan() {
do_check_eq(error.result, Cr.NS_ERROR_NOT_AVAILABLE);
_("Apply a server record that is the same but refers to non-existent folder.");
let record = store.createRecord(bmk1_guid);
let record = await store.createRecord(bmk1_guid);
record.parentid = "non-existent";
store.applyIncoming(record);
await store.applyIncoming(record);
_("Verify that bookmark has been flagged as orphan, has not moved.");
do_check_eq(PlacesUtils.bookmarks.getFolderIdForItem(bmk1_id),
@ -377,25 +377,24 @@ add_test(function test_orphan() {
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
add_test(function test_reparentOrphans() {
add_task(async function test_reparentOrphans() {
try {
let folder1_id = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.toolbarFolder, "Folder1", 0);
let folder1_guid = store.GUIDForId(folder1_id);
let folder1_guid = await store.GUIDForId(folder1_id);
_("Create a bogus orphan record and write the record back to the store to trigger _reparentOrphans.");
PlacesUtils.annotations.setItemAnnotation(
folder1_id, PARENT_ANNO, folder1_guid, 0,
PlacesUtils.annotations.EXPIRE_NEVER);
let record = store.createRecord(folder1_guid);
let record = await store.createRecord(folder1_guid);
record.title = "New title for Folder 1";
store._childrenToOrder = {};
store.applyIncoming(record);
await store.applyIncoming(record);
_("Verify that is has been marked as an orphan even though it couldn't be moved into itself.");
do_check_eq(PlacesUtils.annotations.getItemAnnotation(folder1_id, PARENT_ANNO),
@ -403,14 +402,13 @@ add_test(function test_reparentOrphans() {
} finally {
_("Clean up.");
store.wipe();
run_next_test();
await store.wipe();
}
});
// Tests Bug 806460, in which query records arrive with empty folder
// names and missing bookmark URIs.
add_test(function test_empty_query_doesnt_die() {
add_task(async function test_empty_query_doesnt_die() {
let record = new BookmarkQuery("bookmarks", "8xoDGqKrXf1P");
record.folderName = "";
record.queryId = "";
@ -418,12 +416,11 @@ add_test(function test_empty_query_doesnt_die() {
record.parentid = "toolbar";
// These should not throw.
store.applyIncoming(record);
await store.applyIncoming(record);
delete record.folderName;
store.applyIncoming(record);
await store.applyIncoming(record);
run_next_test();
});
function assertDeleted(id) {
@ -437,7 +434,7 @@ function assertDeleted(id) {
}
add_task(async function test_delete_buffering() {
store.wipe();
await store.wipe();
await PlacesTestUtils.markBookmarksAsSynced();
try {
@ -446,7 +443,7 @@ add_task(async function test_delete_buffering() {
folder.parentName = "Bookmarks Toolbar";
folder.parentid = "toolbar";
folder.title = "Test Folder";
store.applyIncoming(folder);
await store.applyIncoming(folder);
let fxRecord = new Bookmark("bookmarks", "get-firefox1");
@ -461,12 +458,12 @@ add_task(async function test_delete_buffering() {
tbRecord.parentName = "Test Folder";
tbRecord.parentid = "testfolder-1";
store.applyIncoming(fxRecord);
store.applyIncoming(tbRecord);
await store.applyIncoming(fxRecord);
await store.applyIncoming(tbRecord);
let folderId = store.idForGUID(folder.id);
let fxRecordId = store.idForGUID(fxRecord.id);
let tbRecordId = store.idForGUID(tbRecord.id);
let folderId = await store.idForGUID(folder.id);
let fxRecordId = await store.idForGUID(fxRecord.id);
let tbRecordId = await store.idForGUID(tbRecord.id);
_("Check everything was created correctly.");
@ -490,8 +487,8 @@ add_task(async function test_delete_buffering() {
let deleteFxRecord = new PlacesItem("bookmarks", "get-firefox1");
deleteFxRecord.deleted = true;
store.applyIncoming(deleteFolder);
store.applyIncoming(deleteFxRecord);
await store.applyIncoming(deleteFolder);
await store.applyIncoming(deleteFxRecord);
_("Check that we haven't deleted them yet, but that the deletions are queued");
// these will throw if we've deleted them
@ -523,7 +520,7 @@ add_task(async function test_delete_buffering() {
} finally {
_("Clean up.");
store.wipe();
await store.wipe();
}
});

90
services/sync/tests/unit/test_bookmark_tracker.js
Просмотреть файл

@ -16,16 +16,20 @@ Cu.import("resource://gre/modules/osfile.jsm");
Cu.import("resource://testing-common/PlacesTestUtils.jsm");
Cu.import("resource:///modules/PlacesUIUtils.jsm");
Service.engineManager.register(BookmarksEngine);
var engine = Service.engineManager.get("bookmarks");
var store = engine._store;
var tracker = engine._tracker;
store.wipe();
tracker.persistChangedIDs = false;
let engine;
let store;
let tracker;
const DAY_IN_MS = 24 * 60 * 60 * 1000;
add_task(async function setup() {
await Service.engineManager.register(BookmarksEngine);
engine = Service.engineManager.get("bookmarks");
store = engine._store;
tracker = engine._tracker;
tracker.persistChangedIDs = false;
});
// Test helpers.
async function verifyTrackerEmpty() {
await PlacesTestUtils.promiseAsyncUpdates();
@ -42,7 +46,7 @@ async function resetTracker() {
async function cleanup() {
engine.lastSync = 0;
engine._needWeakReupload.clear()
store.wipe();
await store.wipe();
await resetTracker();
await stopTracking();
}
@ -446,7 +450,7 @@ add_task(async function test_onItemAdded() {
let syncFolderID = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.bookmarksMenuFolder, "Sync Folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let syncFolderGUID = engine._store.GUIDForId(syncFolderID);
let syncFolderGUID = await engine._store.GUIDForId(syncFolderID);
await verifyTrackedItems(["menu", syncFolderGUID]);
do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
@ -458,7 +462,7 @@ add_task(async function test_onItemAdded() {
Utils.makeURI("https://example.org/sync"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Sync Bookmark");
let syncBmkGUID = engine._store.GUIDForId(syncBmkID);
let syncBmkGUID = await engine._store.GUIDForId(syncBmkID);
await verifyTrackedItems([syncFolderGUID, syncBmkGUID]);
do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
@ -469,7 +473,7 @@ add_task(async function test_onItemAdded() {
let syncSepID = PlacesUtils.bookmarks.insertSeparator(
PlacesUtils.bookmarks.bookmarksMenuFolder,
PlacesUtils.bookmarks.getItemIndex(syncFolderID));
let syncSepGUID = engine._store.GUIDForId(syncSepID);
let syncSepGUID = await engine._store.GUIDForId(syncSepID);
await verifyTrackedItems(["menu", syncSepGUID]);
do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
} finally {
@ -570,7 +574,7 @@ add_task(async function test_onItemChanged_itemDates() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
await startTracking();
@ -606,7 +610,7 @@ add_task(async function test_onItemChanged_changeBookmarkURI() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
_("Set a tracked annotation to make sure we only notify once");
@ -637,7 +641,7 @@ add_task(async function test_onItemTagged() {
let folder = PlacesUtils.bookmarks.createFolder(
PlacesUtils.bookmarks.bookmarksMenuFolder, "Parent",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folderGUID = engine._store.GUIDForId(folder);
let folderGUID = await engine._store.GUIDForId(folder);
_("Folder ID: " + folder);
_("Folder GUID: " + folderGUID);
@ -646,7 +650,7 @@ add_task(async function test_onItemTagged() {
let b = PlacesUtils.bookmarks.insertBookmark(
folder, uri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bGUID = engine._store.GUIDForId(b);
let bGUID = await engine._store.GUIDForId(b);
_("New item is " + b);
_("GUID: " + bGUID);
@ -675,12 +679,12 @@ add_task(async function test_onItemUntagged() {
let fx1ID = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.bookmarksMenuFolder, uri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let fx1GUID = engine._store.GUIDForId(fx1ID);
let fx1GUID = await engine._store.GUIDForId(fx1ID);
// Different parent and title; same URL.
let fx2ID = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.toolbarFolder, uri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Download Firefox");
let fx2GUID = engine._store.GUIDForId(fx2ID);
let fx2GUID = await engine._store.GUIDForId(fx2ID);
PlacesUtils.tagging.tagURI(uri, ["foo"]);
await startTracking();
@ -810,7 +814,7 @@ add_task(async function test_onItemKeywordChanged() {
let b = PlacesUtils.bookmarks.insertBookmark(
folder, uri,
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bGUID = engine._store.GUIDForId(b);
let bGUID = await engine._store.GUIDForId(b);
_("New item is " + b);
_("GUID: " + bGUID);
@ -915,7 +919,7 @@ add_task(async function test_onItemPostDataChanged() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
await startTracking();
@ -944,7 +948,7 @@ add_task(async function test_onItemAnnoChanged() {
let b = PlacesUtils.bookmarks.insertBookmark(
folder, Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let bGUID = engine._store.GUIDForId(b);
let bGUID = await engine._store.GUIDForId(b);
_("New item is " + b);
_("GUID: " + bGUID);
@ -978,7 +982,7 @@ add_task(async function test_onItemAdded_filtered_root() {
PlacesUtils.bookmarks.placesRoot,
"New root",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let rootGUID = engine._store.GUIDForId(rootID);
let rootGUID = await engine._store.GUIDForId(rootID);
_(`New root GUID: ${rootGUID}`);
_("Insert a bookmark underneath the new root");
@ -987,7 +991,7 @@ add_task(async function test_onItemAdded_filtered_root() {
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let untrackedBmkGUID = engine._store.GUIDForId(untrackedBmkID);
let untrackedBmkGUID = await engine._store.GUIDForId(untrackedBmkID);
_(`New untracked bookmark GUID: ${untrackedBmkGUID}`);
_("Insert a bookmark underneath the Places root");
@ -995,7 +999,7 @@ add_task(async function test_onItemAdded_filtered_root() {
PlacesUtils.bookmarks.placesRoot,
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let rootBmkGUID = engine._store.GUIDForId(rootBmkID);
let rootBmkGUID = await engine._store.GUIDForId(rootBmkID);
_(`New Places root bookmark GUID: ${rootBmkGUID}`);
_("New root and bookmark should be ignored");
@ -1018,7 +1022,7 @@ add_task(async function test_onItemDeleted_filtered_root() {
PlacesUtils.bookmarks.placesRoot,
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
let rootBmkGUID = engine._store.GUIDForId(rootBmkID);
let rootBmkGUID = await engine._store.GUIDForId(rootBmkID);
_(`New Places root bookmark GUID: ${rootBmkGUID}`);
await startTracking();
@ -1171,14 +1175,14 @@ add_task(async function test_onItemMoved() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_("Firefox GUID: " + fx_guid);
let tb_id = PlacesUtils.bookmarks.insertBookmark(
PlacesUtils.bookmarks.bookmarksMenuFolder,
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
_("Thunderbird GUID: " + tb_guid);
await startTracking();
@ -1306,7 +1310,7 @@ add_task(async function test_onItemMoved_setItemIndex() {
PlacesUtils.bookmarks.bookmarksMenuFolder,
"Test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder_guid = engine._store.GUIDForId(folder_id);
let folder_guid = await engine._store.GUIDForId(folder_id);
_(`Folder GUID: ${folder_guid}`);
let tb_id = PlacesUtils.bookmarks.insertBookmark(
@ -1314,7 +1318,7 @@ add_task(async function test_onItemMoved_setItemIndex() {
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Thunderbird");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
_(`Thunderbird GUID: ${tb_guid}`);
let fx_id = PlacesUtils.bookmarks.insertBookmark(
@ -1322,7 +1326,7 @@ add_task(async function test_onItemMoved_setItemIndex() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Firefox");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
let moz_id = PlacesUtils.bookmarks.insertBookmark(
@ -1331,7 +1335,7 @@ add_task(async function test_onItemMoved_setItemIndex() {
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Mozilla"
);
let moz_guid = engine._store.GUIDForId(moz_id);
let moz_guid = await engine._store.GUIDForId(moz_id);
_(`Mozilla GUID: ${moz_guid}`);
await startTracking();
@ -1369,21 +1373,21 @@ add_task(async function test_onItemDeleted_removeFolderTransaction() {
PlacesUtils.bookmarks.bookmarksMenuFolder,
"Test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder_guid = engine._store.GUIDForId(folder_id);
let folder_guid = await engine._store.GUIDForId(folder_id);
_(`Folder GUID: ${folder_guid}`);
let fx_id = PlacesUtils.bookmarks.insertBookmark(
folder_id,
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
let tb_id = PlacesUtils.bookmarks.insertBookmark(
folder_id,
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
_(`Thunderbird GUID: ${tb_guid}`);
await startTracking();
@ -1427,14 +1431,14 @@ add_task(async function test_treeMoved() {
PlacesUtils.bookmarks.bookmarksMenuFolder,
"First test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder1_guid = engine._store.GUIDForId(folder1_id);
let folder1_guid = await engine._store.GUIDForId(folder1_id);
// A second folder in the first.
let folder2_id = PlacesUtils.bookmarks.createFolder(
folder1_id,
"Second test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder2_guid = engine._store.GUIDForId(folder2_id);
let folder2_guid = await engine._store.GUIDForId(folder2_id);
// Create a couple of bookmarks in the second folder.
PlacesUtils.bookmarks.insertBookmark(
@ -1476,7 +1480,7 @@ add_task(async function test_onItemDeleted() {
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
await startTracking();
@ -1616,7 +1620,7 @@ add_task(async function test_onItemDeleted_removeFolderChildren() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
_(`Firefox GUID: ${fx_guid}`);
let tb_id = PlacesUtils.bookmarks.insertBookmark(
@ -1624,7 +1628,7 @@ add_task(async function test_onItemDeleted_removeFolderChildren() {
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
_(`Thunderbird GUID: ${tb_guid}`);
let moz_id = PlacesUtils.bookmarks.insertBookmark(
@ -1633,7 +1637,7 @@ add_task(async function test_onItemDeleted_removeFolderChildren() {
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Mozilla"
);
let moz_guid = engine._store.GUIDForId(moz_id);
let moz_guid = await engine._store.GUIDForId(moz_id);
_(`Mozilla GUID: ${moz_guid}`);
await startTracking();
@ -1658,14 +1662,14 @@ add_task(async function test_onItemDeleted_tree() {
PlacesUtils.bookmarks.bookmarksMenuFolder,
"First test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder1_guid = engine._store.GUIDForId(folder1_id);
let folder1_guid = await engine._store.GUIDForId(folder1_id);
// A second folder in the first.
let folder2_id = PlacesUtils.bookmarks.createFolder(
folder1_id,
"Second test folder",
PlacesUtils.bookmarks.DEFAULT_INDEX);
let folder2_guid = engine._store.GUIDForId(folder2_id);
let folder2_guid = await engine._store.GUIDForId(folder2_id);
// Create a couple of bookmarks in the second folder.
let fx_id = PlacesUtils.bookmarks.insertBookmark(
@ -1673,13 +1677,13 @@ add_task(async function test_onItemDeleted_tree() {
Utils.makeURI("http://getfirefox.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Firefox!");
let fx_guid = engine._store.GUIDForId(fx_id);
let fx_guid = await engine._store.GUIDForId(fx_id);
let tb_id = PlacesUtils.bookmarks.insertBookmark(
folder2_id,
Utils.makeURI("http://getthunderbird.com"),
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let tb_guid = engine._store.GUIDForId(tb_id);
let tb_guid = await engine._store.GUIDForId(tb_id);
await startTracking();

287
services/sync/tests/unit/test_clients_engine.js
Просмотреть файл

@ -12,7 +12,7 @@ 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
var engine = Service.clientsEngine;
let engine;
/**
* Unpack the record with this ID, and verify that it has the same version that
@ -48,10 +48,14 @@ function compareCommands(actual, expected, description) {
equal(allIDs.size, actual.length, "all items have unique IDs");
}
function cleanup() {
add_task(async function setup() {
engine = Service.clientsEngine;
});
async function cleanup() {
Svc.Prefs.resetBranch("");
engine._tracker.clearChangedIDs();
engine._resetClient();
await engine._resetClient();
// We don't finalize storage at cleanup, since we use the same clients engine
// instance across all tests.
}
@ -95,14 +99,14 @@ add_task(async function test_bad_hmac() {
try {
await configureIdentity({username: "foo"}, server);
Service.login();
await Service.login();
generateNewKeys(Service.collectionKeys);
_("First sync, client record is uploaded");
equal(engine.lastRecordUpload, 0);
check_clients_count(0);
engine._sync();
await engine._sync();
check_clients_count(1);
ok(engine.lastRecordUpload > 0);
@ -116,14 +120,14 @@ add_task(async function test_bad_hmac() {
_("Change our keys and our client ID, reupload keys.");
let oldLocalID = engine.localID; // Preserve to test for deletion!
engine.localID = Utils.makeGUID();
engine.resetClient();
await engine.resetClient();
generateNewKeys(Service.collectionKeys);
let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
serverKeys.encrypt(Service.identity.syncKeyBundle);
ok((await serverKeys.upload(Service.resource(Service.cryptoKeysURL))).success);
_("Sync.");
engine._sync();
await engine._sync();
_("Old record " + oldLocalID + " was deleted, new one uploaded.");
check_clients_count(1);
@ -133,12 +137,12 @@ add_task(async function test_bad_hmac() {
"That means we get an HMAC error but redownload keys.");
Service.lastHMACEvent = 0;
engine.localID = Utils.makeGUID();
engine.resetClient();
await engine.resetClient();
generateNewKeys(Service.collectionKeys);
deletedCollections = [];
deletedItems = [];
check_clients_count(1);
engine._sync();
await engine._sync();
_("Old record was not deleted, new one uploaded.");
equal(deletedCollections.length, 0);
@ -150,7 +154,7 @@ add_task(async function test_bad_hmac() {
user.collection("clients")._wbos = {};
Service.lastHMACEvent = 0;
engine.localID = Utils.makeGUID();
engine.resetClient();
await engine.resetClient();
deletedCollections = [];
deletedItems = [];
check_clients_count(0);
@ -158,7 +162,7 @@ add_task(async function test_bad_hmac() {
await uploadNewKeys();
// Sync once to upload a record.
engine._sync();
await engine._sync();
check_clients_count(1);
// Generate and upload new keys, so the old client record is wrong.
@ -169,13 +173,13 @@ add_task(async function test_bad_hmac() {
// the bad client record.
oldLocalID = engine.localID; // Preserve to test for deletion!
engine.localID = Utils.makeGUID();
engine.resetClient();
await engine.resetClient();
generateNewKeys(Service.collectionKeys);
let oldKey = Service.collectionKeys.keyForCollection();
equal(deletedCollections.length, 0);
equal(deletedItems.length, 0);
engine._sync();
await engine._sync();
equal(deletedItems.length, 1);
check_client_deleted(oldLocalID);
check_clients_count(1);
@ -183,7 +187,7 @@ add_task(async function test_bad_hmac() {
ok(!oldKey.equals(newKey));
} finally {
cleanup();
await cleanup();
await promiseStopServer(server);
}
});
@ -198,7 +202,7 @@ add_task(async function test_properties() {
engine.lastRecordUpload = now / 1000;
equal(engine.lastRecordUpload, Math.floor(now / 1000));
} finally {
cleanup();
await cleanup();
}
});
@ -237,12 +241,13 @@ add_task(async function test_full_sync() {
_("First sync. 2 records downloaded; our record uploaded.");
strictEqual(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
ok(engine.lastRecordUpload > 0);
deepEqual(user.collection("clients").keys().sort(),
[activeID, deletedID, engine.localID].sort(),
"Our record should be uploaded on first sync");
deepEqual(Object.keys(store.getAllIDs()).sort(),
let ids = await store.getAllIDs();
deepEqual(Object.keys(ids).sort(),
[activeID, deletedID, engine.localID].sort(),
"Other clients should be downloaded on first sync");
@ -251,14 +256,15 @@ add_task(async function test_full_sync() {
collection.remove(deletedID);
// Simulate a timestamp update in info/collections.
engine.lastModified = now;
engine._sync();
await engine._sync();
_("Record should be updated");
deepEqual(Object.keys(store.getAllIDs()).sort(),
ids = await store.getAllIDs();
deepEqual(Object.keys(ids).sort(),
[activeID, engine.localID].sort(),
"Deleted client should be removed on next sync");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -286,7 +292,7 @@ add_task(async function test_sync() {
_("First sync. Client record is uploaded.");
equal(clientWBO(), undefined);
equal(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
ok(!!clientWBO().payload);
ok(engine.lastRecordUpload > 0);
@ -294,7 +300,7 @@ add_task(async function test_sync() {
engine.lastRecordUpload -= MORE_THAN_CLIENTS_TTL_REFRESH;
let lastweek = engine.lastRecordUpload;
clientWBO().payload = undefined;
engine._sync();
await engine._sync();
ok(!!clientWBO().payload);
ok(engine.lastRecordUpload > lastweek);
@ -305,12 +311,12 @@ add_task(async function test_sync() {
_("Time travel one day back, no record uploaded.");
engine.lastRecordUpload -= LESS_THAN_CLIENTS_TTL_REFRESH;
let yesterday = engine.lastRecordUpload;
engine._sync();
await engine._sync();
equal(clientWBO().payload, undefined);
equal(engine.lastRecordUpload, yesterday);
} finally {
cleanup();
await cleanup();
await promiseStopServer(server);
}
});
@ -344,7 +350,7 @@ add_task(async function test_client_name_change() {
Svc.Obs.notify("weave:engine:stop-tracking");
cleanup();
await cleanup();
});
add_task(async function test_last_modified() {
@ -371,7 +377,7 @@ add_task(async function test_last_modified() {
let collection = user.collection("clients");
_("Sync to download the record");
engine._sync();
await engine._sync();
equal(engine._store._remoteClients[activeID].serverLastModified, now - 10,
"last modified in the local record is correctly the server last-modified");
@ -380,7 +386,7 @@ add_task(async function test_last_modified() {
// set a new name to make sure we really did upload.
engine._store._remoteClients[activeID].name = "New name";
engine._modified.set(activeID, 0);
engine._uploadOutgoing();
await engine._uploadOutgoing();
_("Local record should have updated timestamp");
ok(engine._store._remoteClients[activeID].serverLastModified >= now);
@ -391,7 +397,7 @@ add_task(async function test_last_modified() {
equal(payload.serverLastModified, undefined);
} finally {
cleanup();
await cleanup();
server.deleteCollections("foo");
await promiseStopServer(server);
}
@ -405,17 +411,17 @@ add_task(async function test_send_command() {
let remoteId = Utils.makeGUID();
let rec = new ClientsRec("clients", remoteId);
store.create(rec);
store.createRecord(remoteId, "clients");
await store.create(rec);
await store.createRecord(remoteId, "clients");
let action = "testCommand";
let args = ["foo", "bar"];
let extra = { flowID: "flowy" }
engine._sendCommandToClient(action, args, remoteId, extra);
await engine._sendCommandToClient(action, args, remoteId, extra);
let newRecord = store._remoteClients[remoteId];
let clientCommands = engine._readCommands()[remoteId];
let clientCommands = (await engine._readCommands())[remoteId];
notEqual(newRecord, undefined);
equal(clientCommands.length, 1);
@ -427,7 +433,7 @@ add_task(async function test_send_command() {
notEqual(tracker.changedIDs[remoteId], undefined);
cleanup();
await cleanup();
});
add_task(async function test_command_validation() {
@ -453,15 +459,15 @@ add_task(async function test_command_validation() {
let remoteId = Utils.makeGUID();
let rec = new ClientsRec("clients", remoteId);
store.create(rec);
store.createRecord(remoteId, "clients");
await store.create(rec);
await store.createRecord(remoteId, "clients");
engine.sendCommand(action, args, remoteId);
await engine.sendCommand(action, args, remoteId);
let newRecord = store._remoteClients[remoteId];
notEqual(newRecord, undefined);
let clientCommands = engine._readCommands()[remoteId];
let clientCommands = (await engine._readCommands())[remoteId];
if (expectedResult) {
_("Ensuring command is sent: " + action);
@ -483,7 +489,7 @@ add_task(async function test_command_validation() {
}
}
cleanup();
await cleanup();
});
add_task(async function test_command_duplication() {
@ -492,32 +498,32 @@ add_task(async function test_command_duplication() {
let store = engine._store;
let remoteId = Utils.makeGUID();
let rec = new ClientsRec("clients", remoteId);
store.create(rec);
store.createRecord(remoteId, "clients");
await store.create(rec);
await store.createRecord(remoteId, "clients");
let action = "resetAll";
let args = [];
engine.sendCommand(action, args, remoteId);
engine.sendCommand(action, args, remoteId);
await engine.sendCommand(action, args, remoteId);
await engine.sendCommand(action, args, remoteId);
let clientCommands = engine._readCommands()[remoteId];
let clientCommands = (await engine._readCommands())[remoteId];
equal(clientCommands.length, 1);
_("Check variant args length");
engine._saveCommands({});
await engine._saveCommands({});
action = "resetEngine";
engine.sendCommand(action, [{ x: "foo" }], remoteId);
engine.sendCommand(action, [{ x: "bar" }], remoteId);
await engine.sendCommand(action, [{ x: "foo" }], remoteId);
await engine.sendCommand(action, [{ x: "bar" }], remoteId);
_("Make sure we spot a real dupe argument.");
engine.sendCommand(action, [{ x: "bar" }], remoteId);
await engine.sendCommand(action, [{ x: "bar" }], remoteId);
clientCommands = engine._readCommands()[remoteId];
clientCommands = (await engine._readCommands())[remoteId];
equal(clientCommands.length, 2);
cleanup();
await cleanup();
});
add_task(async function test_command_invalid_client() {
@ -527,14 +533,14 @@ add_task(async function test_command_invalid_client() {
let error;
try {
engine.sendCommand("wipeAll", [], id);
await engine.sendCommand("wipeAll", [], id);
} catch (ex) {
error = ex;
}
equal(error.message.indexOf("Unknown remote client ID: "), 0);
cleanup();
await cleanup();
});
add_task(async function test_process_incoming_commands() {
@ -555,11 +561,11 @@ add_task(async function test_process_incoming_commands() {
});
// logout command causes processIncomingCommands to return explicit false.
ok(!engine.processIncomingCommands());
ok(!(await engine.processIncomingCommands()));
await logoutPromise;
cleanup();
await cleanup();
});
add_task(async function test_filter_duplicate_names() {
@ -610,16 +616,17 @@ add_task(async function test_filter_duplicate_names() {
_("First sync");
strictEqual(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
ok(engine.lastRecordUpload > 0);
deepEqual(user.collection("clients").keys().sort(),
[recentID, dupeID, oldID, engine.localID].sort(),
"Our record should be uploaded on first sync");
deepEqual(Object.keys(store.getAllIDs()).sort(),
let ids = await store.getAllIDs();
deepEqual(Object.keys(ids).sort(),
[recentID, dupeID, oldID, engine.localID].sort(),
"Duplicate ID should remain in getAllIDs");
ok(engine._store.itemExists(dupeID), "Dupe ID should be considered as existing for Sync methods.");
ok((await engine._store.itemExists(dupeID)), "Dupe ID should be considered as existing for Sync methods.");
ok(!engine.remoteClientExists(dupeID), "Dupe ID should not be considered as existing for external methods.");
// dupe desktop should not appear in .deviceTypes.
@ -644,7 +651,7 @@ add_task(async function test_filter_duplicate_names() {
counts = subject;
});
engine._sync();
await engine._sync();
equal(counts.applied, 0); // We didn't report applying any records.
equal(counts.reconciled, 4); // We reported reconcilliation for all records
equal(counts.succeeded, 0);
@ -652,8 +659,8 @@ add_task(async function test_filter_duplicate_names() {
equal(counts.newFailed, 0);
_("Broadcast logout to all clients");
engine.sendCommand("logout", []);
engine._sync();
await engine.sendCommand("logout", []);
await engine._sync();
let collection = server.getCollection("foo", "clients");
let recentPayload = JSON.parse(JSON.parse(collection.payload(recentID)).ciphertext);
@ -679,9 +686,10 @@ add_task(async function test_filter_duplicate_names() {
}), now - 10));
_("Second sync.");
engine._sync();
await engine._sync();
deepEqual(Object.keys(store.getAllIDs()).sort(),
ids = await store.getAllIDs();
deepEqual(Object.keys(ids).sort(),
[recentID, oldID, dupeID, engine.localID].sort(),
"Stale client synced, so it should no longer be marked as a dupe");
@ -701,7 +709,7 @@ add_task(async function test_filter_duplicate_names() {
equal(engine.remoteClients.length, 3, "recently synced dupe should now be in remoteClients");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -714,7 +722,7 @@ add_task(async function test_filter_duplicate_names() {
add_task(async function test_command_sync() {
_("Ensure that commands are synced across clients.");
engine._store.wipe();
await engine._store.wipe();
generateNewKeys(Service.collectionKeys);
let server = serverForFoo(engine);
@ -739,7 +747,7 @@ add_task(async function test_command_sync() {
try {
_("Syncing.");
engine._sync();
await engine._sync();
_("Checking remote record was downloaded.");
let clientRecord = engine._store._remoteClients[remoteId];
@ -747,10 +755,10 @@ add_task(async function test_command_sync() {
equal(clientRecord.commands.length, 0);
_("Send a command to the remote client.");
engine.sendCommand("wipeAll", []);
let clientCommands = engine._readCommands()[remoteId];
await engine.sendCommand("wipeAll", []);
let clientCommands = (await engine._readCommands())[remoteId];
equal(clientCommands.length, 1);
engine._sync();
await engine._sync();
_("Checking record was uploaded.");
notEqual(clientWBO(engine.localID).payload, undefined);
@ -762,7 +770,7 @@ add_task(async function test_command_sync() {
engine._resetClient();
equal(engine.localID, remoteId);
_("Performing sync on resetted client.");
engine._sync();
await engine._sync();
notEqual(engine.localCommands, undefined);
equal(engine.localCommands.length, 1);
@ -771,7 +779,7 @@ add_task(async function test_command_sync() {
equal(command.args.length, 0);
} finally {
cleanup();
await cleanup();
try {
let collection = server.getCollection("foo", "clients");
@ -785,7 +793,7 @@ add_task(async function test_command_sync() {
add_task(async function test_clients_not_in_fxa_list() {
_("Ensure that clients not in the FxA devices list are marked as stale.");
engine._store.wipe();
await engine._store.wipe();
generateNewKeys(Service.collectionKeys);
let server = serverForFoo(engine);
@ -823,14 +831,14 @@ add_task(async function test_clients_not_in_fxa_list() {
try {
_("Syncing.");
engine._sync();
await engine._sync();
ok(!engine._store._remoteClients[remoteId].stale);
ok(engine._store._remoteClients[remoteId2].stale);
} finally {
engine.fxAccounts = fxAccounts;
cleanup();
await cleanup();
try {
let collection = server.getCollection("foo", "clients");
@ -850,20 +858,20 @@ add_task(async function test_send_uri_to_client_for_display() {
let remoteId = Utils.makeGUID();
let rec = new ClientsRec("clients", remoteId);
rec.name = "remote";
store.create(rec);
store.createRecord(remoteId, "clients");
await store.create(rec);
await 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);
await engine.sendURIToClientForDisplay(uri, remoteId, title);
let newRecord = store._remoteClients[remoteId];
notEqual(newRecord, undefined);
let clientCommands = engine._readCommands()[remoteId];
let clientCommands = (await engine._readCommands())[remoteId];
equal(clientCommands.length, 1);
let command = clientCommands[0];
@ -881,14 +889,14 @@ add_task(async function test_send_uri_to_client_for_display() {
let error;
try {
engine.sendURIToClientForDisplay(uri, unknownId);
await engine.sendURIToClientForDisplay(uri, unknownId);
} catch (ex) {
error = ex;
}
equal(error.message.indexOf("Unknown remote client ID: "), 0);
cleanup();
await cleanup();
});
add_task(async function test_receive_display_uri() {
@ -922,7 +930,7 @@ add_task(async function test_receive_display_uri() {
Svc.Obs.add(ev, handler);
});
ok(engine.processIncomingCommands());
ok((await engine.processIncomingCommands()));
let { subject, data } = await promiseDisplayURI;
@ -931,14 +939,14 @@ add_task(async function test_receive_display_uri() {
equal(subject[0].title, title);
equal(data, null);
cleanup();
await cleanup();
});
add_task(async function test_optional_client_fields() {
_("Ensure that we produce records with the fields added in Bug 1097222.");
const SUPPORTED_PROTOCOL_VERSIONS = ["1.5"];
let local = engine._store.createRecord(engine.localID, "clients");
let local = await engine._store.createRecord(engine.localID, "clients");
equal(local.name, engine.localName);
equal(local.type, engine.localType);
equal(local.version, Services.appinfo.version);
@ -957,7 +965,7 @@ add_task(async function test_optional_client_fields() {
// We don't currently populate device or formfactor.
// See Bug 1100722, Bug 1100723.
cleanup();
await cleanup();
});
add_task(async function test_merge_commands() {
@ -1000,11 +1008,11 @@ add_task(async function test_merge_commands() {
try {
_("First sync. 2 records downloaded.");
strictEqual(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
_("Broadcast logout to all clients");
engine.sendCommand("logout", []);
engine._sync();
await engine.sendCommand("logout", []);
await engine._sync();
let collection = server.getCollection("foo", "clients");
let desktopPayload = JSON.parse(JSON.parse(collection.payload(desktopID)).ciphertext);
@ -1020,7 +1028,7 @@ add_task(async function test_merge_commands() {
compareCommands(mobilePayload.commands, [{ command: "logout", args: [] }],
"Should not send a duplicate logout to the mobile client");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -1052,11 +1060,11 @@ add_task(async function test_duplicate_remote_commands() {
try {
_("First sync. 1 record downloaded.");
strictEqual(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
_("Send tab to client");
engine.sendCommand("displayURI", ["https://example.com", engine.localID, "Yak Herders Anonymous"]);
engine._sync();
await engine.sendCommand("displayURI", ["https://example.com", engine.localID, "Yak Herders Anonymous"]);
await engine._sync();
_("Simulate the desktop client consuming the command and syncing to the server");
server.insertWBO("foo", "clients", new ServerWBO(desktopID, encryptPayload({
@ -1069,8 +1077,8 @@ add_task(async function test_duplicate_remote_commands() {
}), now - 10));
_("Send another tab to the desktop client");
engine.sendCommand("displayURI", ["https://foobar.com", engine.localID, "Foo bar!"], desktopID);
engine._sync();
await engine.sendCommand("displayURI", ["https://foobar.com", engine.localID, "Foo bar!"], desktopID);
await engine._sync();
let collection = server.getCollection("foo", "clients");
let desktopPayload = JSON.parse(JSON.parse(collection.payload(desktopID)).ciphertext);
@ -1079,7 +1087,7 @@ add_task(async function test_duplicate_remote_commands() {
args: ["https://foobar.com", engine.localID, "Foo bar!"],
}], "Should only send the second command to the desktop client");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -1124,14 +1132,14 @@ add_task(async function test_upload_after_reboot() {
try {
_("First sync. 2 records downloaded.");
strictEqual(engine.lastRecordUpload, 0);
engine._sync();
await engine._sync();
_("Send tab to client");
engine.sendCommand("displayURI", ["https://example.com", engine.localID, "Yak Herders Anonymous"], deviceBID);
await engine.sendCommand("displayURI", ["https://example.com", engine.localID, "Yak Herders Anonymous"], deviceBID);
const oldUploadOutgoing = SyncEngine.prototype._uploadOutgoing;
SyncEngine.prototype._uploadOutgoing = () => engine._onRecordsWritten([], [deviceBID]);
engine._sync();
SyncEngine.prototype._uploadOutgoing = async () => engine._onRecordsWritten([], [deviceBID]);
await engine._sync();
let collection = server.getCollection("foo", "clients");
let deviceBPayload = JSON.parse(JSON.parse(collection.payload(deviceBID)).ciphertext);
@ -1152,8 +1160,9 @@ add_task(async function test_upload_after_reboot() {
// Simulate reboot
SyncEngine.prototype._uploadOutgoing = oldUploadOutgoing;
engine = Service.clientsEngine = new ClientEngine(Service);
await engine.initialize();
engine._sync();
await engine._sync();
deviceBPayload = JSON.parse(JSON.parse(collection.payload(deviceBID)).ciphertext);
compareCommands(deviceBPayload.commands, [{
@ -1161,7 +1170,7 @@ add_task(async function test_upload_after_reboot() {
args: ["https://example.com", engine.localID, "Yak Herders Anonymous"],
}], "Should only had written our outgoing command");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -1222,12 +1231,12 @@ add_task(async function test_keep_cleared_commands_after_reboot() {
let collection = server.getCollection("foo", "clients");
const oldUploadOutgoing = SyncEngine.prototype._uploadOutgoing;
SyncEngine.prototype._uploadOutgoing = () => engine._onRecordsWritten([], [deviceBID]);
SyncEngine.prototype._uploadOutgoing = async () => engine._onRecordsWritten([], [deviceBID]);
let commandsProcessed = 0;
engine._handleDisplayURIs = (uris) => { commandsProcessed = uris.length };
engine._sync();
engine.processIncomingCommands(); // Not called by the engine.sync(), gotta call it ourselves
await engine._sync();
await engine.processIncomingCommands(); // Not called by the engine.sync(), gotta call it ourselves
equal(commandsProcessed, 2, "We processed 2 commands");
let localRemoteRecord = JSON.parse(JSON.parse(collection.payload(engine.localID)).ciphertext);
@ -1265,20 +1274,22 @@ add_task(async function test_keep_cleared_commands_after_reboot() {
// Simulate reboot
SyncEngine.prototype._uploadOutgoing = oldUploadOutgoing;
engine = Service.clientsEngine = new ClientEngine(Service);
await engine.initialize();
commandsProcessed = 0;
engine._handleDisplayURIs = (uris) => { commandsProcessed = uris.length };
engine._sync();
engine.processIncomingCommands();
await engine._sync();
await engine.processIncomingCommands();
equal(commandsProcessed, 1, "We processed one command (the other were cleared)");
localRemoteRecord = JSON.parse(JSON.parse(collection.payload(deviceBID)).ciphertext);
deepEqual(localRemoteRecord.commands, [], "Should be empty");
} finally {
cleanup();
await cleanup();
// Reset service (remove mocks)
engine = Service.clientsEngine = new ClientEngine(Service);
await engine.initialize();
engine._resetClient();
try {
@ -1320,15 +1331,15 @@ add_task(async function test_deleted_commands() {
try {
_("First sync. 2 records downloaded.");
engine._sync();
await engine._sync();
_("Delete a record on the server.");
let collection = server.getCollection("foo", "clients");
collection.remove(deletedID);
_("Broadcast a command to all clients");
engine.sendCommand("logout", []);
engine._sync();
await engine.sendCommand("logout", []);
await engine._sync();
deepEqual(collection.keys().sort(), [activeID, engine.localID].sort(),
"Should not reupload deleted clients");
@ -1337,7 +1348,7 @@ add_task(async function test_deleted_commands() {
compareCommands(activePayload.commands, [{ command: "logout", args: [] }],
"Should send the command to the active client");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -1360,7 +1371,7 @@ add_task(async function test_send_uri_ack() {
let fakeSenderID = Utils.makeGUID();
_("Initial sync for empty clients collection");
engine._sync();
await engine._sync();
let collection = server.getCollection("foo", "clients");
let ourPayload = JSON.parse(JSON.parse(collection.payload(engine.localID)).ciphertext);
ok(ourPayload, "Should upload our client record");
@ -1374,25 +1385,25 @@ add_task(async function test_send_uri_ack() {
server.insertWBO("foo", "clients", new ServerWBO(engine.localID, encryptPayload(ourPayload), now));
_("Sync again");
engine._sync();
await engine._sync();
compareCommands(engine.localCommands, [{
command: "displayURI",
args: ["https://example.com", fakeSenderID, "Yak Herders Anonymous"],
}], "Should receive incoming URI");
ok(engine.processIncomingCommands(), "Should process incoming commands");
const clearedCommands = engine._readCommands()[engine.localID];
ok((await engine.processIncomingCommands()), "Should process incoming commands");
const clearedCommands = (await engine._readCommands())[engine.localID];
compareCommands(clearedCommands, [{
command: "displayURI",
args: ["https://example.com", fakeSenderID, "Yak Herders Anonymous"],
}], "Should mark the commands as cleared after processing");
_("Check that the command was removed on the server");
engine._sync();
await engine._sync();
ourPayload = JSON.parse(JSON.parse(collection.payload(engine.localID)).ciphertext);
ok(ourPayload, "Should upload the synced client record");
deepEqual(ourPayload.commands, [], "Should not reupload cleared commands");
} finally {
cleanup();
await cleanup();
try {
server.deleteCollections("foo");
@ -1405,7 +1416,7 @@ add_task(async function test_send_uri_ack() {
add_task(async function test_command_sync() {
_("Notify other clients when writing their record.");
engine._store.wipe();
await engine._store.wipe();
generateNewKeys(Service.collectionKeys);
let server = serverForFoo(engine);
@ -1437,23 +1448,23 @@ add_task(async function test_command_sync() {
try {
equal(collection.count(), 2, "2 remote records written");
engine._sync();
await engine._sync();
equal(collection.count(), 3, "3 remote records written (+1 for the synced local record)");
engine.sendCommand("wipeAll", []);
await engine.sendCommand("wipeAll", []);
engine._tracker.addChangedID(engine.localID);
const getClientFxaDeviceId = sinon.stub(engine, "getClientFxaDeviceId", (id) => "fxa-" + id);
const engineMock = sinon.mock(engine);
let _notifyCollectionChanged = engineMock.expects("_notifyCollectionChanged")
.withArgs(["fxa-" + remoteId, "fxa-" + remoteId2]);
_("Syncing.");
engine._sync();
await engine._sync();
_notifyCollectionChanged.verify();
engineMock.restore();
getClientFxaDeviceId.restore();
} finally {
cleanup();
await cleanup();
engine._tracker.clearChangedIDs();
try {
@ -1500,9 +1511,9 @@ add_task(async function ensureSameFlowIDs() {
protocols: ["1.5"]
}), Date.now() / 1000));
engine._sync();
engine.sendCommand("wipeAll", []);
engine._sync();
await engine._sync();
await engine.sendCommand("wipeAll", []);
await engine._sync();
equal(events.length, 2);
// we don't know what the flowID is, but do know it should be the same.
equal(events[0].extra.flowID, events[1].extra.flowID);
@ -1513,8 +1524,8 @@ add_task(async function ensureSameFlowIDs() {
// check it's correctly used when we specify a flow ID
events.length = 0;
let flowID = Utils.makeGUID();
engine.sendCommand("wipeAll", [], null, { flowID });
engine._sync();
await engine.sendCommand("wipeAll", [], null, { flowID });
await engine._sync();
equal(events.length, 2);
equal(events[0].extra.flowID, flowID);
equal(events[1].extra.flowID, flowID);
@ -1526,8 +1537,8 @@ add_task(async function ensureSameFlowIDs() {
// and that it works when something else is in "extra"
events.length = 0;
engine.sendCommand("wipeAll", [], null, { reason: "testing" });
engine._sync();
await engine.sendCommand("wipeAll", [], null, { reason: "testing" });
await engine._sync();
equal(events.length, 2);
equal(events[0].extra.flowID, events[1].extra.flowID);
equal(events[0].extra.reason, "testing");
@ -1539,8 +1550,8 @@ add_task(async function ensureSameFlowIDs() {
// and when both are specified.
events.length = 0;
engine.sendCommand("wipeAll", [], null, { reason: "testing", flowID });
engine._sync();
await engine.sendCommand("wipeAll", [], null, { reason: "testing", flowID });
await engine._sync();
equal(events.length, 2);
equal(events[0].extra.flowID, flowID);
equal(events[1].extra.flowID, flowID);
@ -1592,17 +1603,17 @@ add_task(async function test_duplicate_commands_telemetry() {
protocols: ["1.5"]
}), Date.now() / 1000));
engine._sync();
await engine._sync();
// Make sure deduping works before syncing
engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
await engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
await engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
equal(events.length, 1);
engine._sync();
await engine._sync();
// And after syncing.
engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
await engine.sendURIToClientForDisplay("https://example.com", remoteId, "Example");
equal(events.length, 1);
// Ensure we aren't deduping commands to different clients
engine.sendURIToClientForDisplay("https://example.com", remoteId2, "Example");
await engine.sendURIToClientForDisplay("https://example.com", remoteId2, "Example");
equal(events.length, 2);
} finally {
Service.recordTelemetryEvent = origRecordTelemetryEvent;
@ -1634,11 +1645,11 @@ add_task(async function test_other_clients_notified_on_first_sync() {
try {
engine.lastRecordUpload = 0;
_("First sync, should notify other clients");
engine._sync();
await engine._sync();
equal(calls, 1);
_("Second sync, should not notify other clients");
engine._sync();
await engine._sync();
equal(calls, 1);
} finally {
engine.fxAccounts = fxAccounts;
@ -1689,11 +1700,11 @@ add_task(async function process_incoming_refreshes_known_stale_clients() {
});
engine._knownStaleFxADeviceIds = null;
engine._processIncoming();
await engine._processIncoming();
ok(stubRefresh.calledOnce, "Should refresh the known stale clients");
stubRefresh.reset();
engine._processIncoming();
await engine._processIncoming();
ok(stubRefresh.notCalled, "Should not refresh the known stale clients since it's already populated");
stubProcessIncoming.restore();

4
services/sync/tests/unit/test_clients_escape.js
Просмотреть файл

@ -21,7 +21,7 @@ add_task(async function test_clients_escape() {
engine.localName = "wéävê";
_("Make sure we have the expected record");
let record = engine._createRecord("ascii");
let record = await engine._createRecord("ascii");
do_check_eq(record.id, "ascii");
do_check_eq(record.name, "wéävê");
@ -48,7 +48,7 @@ add_task(async function test_clients_escape() {
do_check_eq(record.name, "wéävê");
_("Sanity check that creating the record also gives the same");
record = engine._createRecord("ascii");
record = await engine._createRecord("ascii");
do_check_eq(record.id, "ascii");
do_check_eq(record.name, "wéävê");
} finally {

13
services/sync/tests/unit/test_collections_recovery.js
Просмотреть файл

@ -6,6 +6,8 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging("Trace");
add_task(async function test_missing_crypto_collection() {
enableValidationPrefs();
@ -46,9 +48,9 @@ add_task(async function test_missing_crypto_collection() {
try {
let fresh = 0;
let orig = Service._freshStart;
Service._freshStart = function() {
Service._freshStart = async function() {
_("Called _freshStart.");
orig.call(Service);
await orig.call(Service);
fresh++;
};
@ -58,7 +60,7 @@ add_task(async function test_missing_crypto_collection() {
fresh = 0;
_("Regular sync: no need to freshStart.");
Service.sync();
await Service.sync();
do_check_eq(fresh, 0);
_("Simulate a bad info/collections.");
@ -76,8 +78,3 @@ add_task(async function test_missing_crypto_collection() {
await promiseStopServer(server);
}
});
function run_test() {
initTestLogging("Trace");
run_next_test();
}

6
services/sync/tests/unit/test_corrupt_keys.js
Просмотреть файл

@ -18,7 +18,7 @@ add_task(async function test_locally_changed_keys() {
let hmacErrorCount = 0;
function counting(f) {
return function() {
return async function() {
hmacErrorCount++;
return f.call(this);
};
@ -42,7 +42,7 @@ add_task(async function test_locally_changed_keys() {
// We aren't doing a .login yet, so fudge the cluster URL.
Service.clusterURL = Service.identity._token.endpoint;
Service.engineManager.register(HistoryEngine);
await Service.engineManager.register(HistoryEngine);
Service.engineManager.unregister("addons");
function corrupt_local_keys() {
@ -67,7 +67,7 @@ add_task(async function test_locally_changed_keys() {
do_check_true((await serverKeys.upload(Service.resource(Service.cryptoKeysURL))).success);
// Check that login works.
do_check_true(Service.login());
do_check_true((await Service.login()));
do_check_true(Service.isLoggedIn);
// Sync should upload records.

12
services/sync/tests/unit/test_declined.js
Просмотреть файл

@ -7,10 +7,6 @@ Cu.import("resource://services-sync/engines.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-common/observers.js");
function run_test() {
run_next_test();
}
function PetrolEngine() {}
PetrolEngine.prototype.name = "petrol";
@ -46,7 +42,7 @@ function getEngineManager() {
* declined, and a notification is sent for our locally disabled-but-not-
* declined engines.
*/
add_test(function testOldMeta() {
add_task(async function testOldMeta() {
let meta = {
payload: {
engines: {
@ -63,7 +59,7 @@ add_test(function testOldMeta() {
// Update enabled from meta/global.
let engineSync = new EngineSynchronizer(Service);
engineSync._updateEnabledFromMeta(meta, 3, manager);
await engineSync._updateEnabledFromMeta(meta, 3, manager);
Assert.ok(manager._engines["petrol"].enabled, "'petrol' locally enabled.");
Assert.ok(manager._engines["diesel"].enabled, "'diesel' locally enabled.");
@ -96,7 +92,7 @@ add_test(function testOldMeta() {
* record is marked as changed and includes all declined
* engines.
*/
add_test(function testDeclinedMeta() {
add_task(async function testDeclinedMeta() {
let meta = {
payload: {
engines: {
@ -142,8 +138,6 @@ add_test(function testDeclinedMeta() {
Assert.ok(0 <= meta.payload.declined.indexOf("nonexistent"), "meta/global's declined contains 'nonexistent'.");
Assert.ok(0 <= meta.payload.declined.indexOf("localdecline"), "meta/global's declined contains 'localdecline'.");
Assert.strictEqual(true, meta.changed, "meta/global was changed.");
run_next_test();
}
Observers.add("weave:engines:notdeclined", onNotDeclined);

6
services/sync/tests/unit/test_doctor.js
Просмотреть файл

@ -77,7 +77,7 @@ add_task(async function test_repairs_start() {
}
}
let requestor = {
startRepairs(validationInfo, flowID) {
async startRepairs(validationInfo, flowID) {
ok(flowID, "got a flow ID");
equal(validationInfo, problems);
repairStarted = true;
@ -111,7 +111,7 @@ add_task(async function test_repairs_start() {
add_task(async function test_repairs_advanced_daily() {
let repairCalls = 0;
let requestor = {
continueRepairs() {
async continueRepairs() {
repairCalls++;
},
tryServerOnlyRepairs() {
@ -165,7 +165,7 @@ add_task(async function test_repairs_skip_if_cant_vaidate() {
}
}
let requestor = {
startRepairs(validationInfo, flowID) {
async startRepairs(validationInfo, flowID) {
assert.ok(false, "Never should start repairs");
},
tryServerOnlyRepairs() {

14
services/sync/tests/unit/test_engine.js
Просмотреть файл

@ -14,7 +14,7 @@ function SteamStore(engine) {
SteamStore.prototype = {
__proto__: Store.prototype,
wipe() {
async wipe() {
this.wasWiped = true;
}
};
@ -37,11 +37,11 @@ SteamEngine.prototype = {
_storeObj: SteamStore,
_trackerObj: SteamTracker,
_resetClient() {
async _resetClient() {
this.wasReset = true;
},
_sync() {
async _sync() {
this.wasSynced = true;
}
};
@ -105,7 +105,7 @@ add_task(async function test_resetClient() {
let engine = new SteamEngine("Steam", Service);
do_check_false(engine.wasReset);
engine.resetClient();
await engine.resetClient();
do_check_true(engine.wasReset);
do_check_eq(engineObserver.topics[0], "weave:engine:reset-client:start");
do_check_eq(engineObserver.topics[1], "weave:engine:reset-client:finish");
@ -140,7 +140,7 @@ add_task(async function test_wipeClient() {
do_check_true(engine._tracker.addChangedID("a-changed-id"));
do_check_true("a-changed-id" in engine._tracker.changedIDs);
engine.wipeClient();
await engine.wipeClient();
do_check_true(engine.wasReset);
do_check_true(engine._store.wasWiped);
do_check_eq(JSON.stringify(engine._tracker.changedIDs), "{}");
@ -173,14 +173,14 @@ add_task(async function test_sync() {
_("Engine.sync doesn't call _sync if it's not enabled");
do_check_false(engine.enabled);
do_check_false(engine.wasSynced);
engine.sync();
await engine.sync();
do_check_false(engine.wasSynced);
_("Engine.sync calls _sync if it's enabled");
engine.enabled = true;
engine.sync();
await engine.sync();
do_check_true(engine.wasSynced);
do_check_eq(engineObserver.topics[0], "weave:engine:sync:start");
do_check_eq(engineObserver.topics[1], "weave:engine:sync:finish");

8
services/sync/tests/unit/test_engine_abort.js
Просмотреть файл

@ -30,7 +30,7 @@ add_task(async function test_processIncoming_abort() {
meta_global.payload.engines = {rotary: {version: engine.version,
syncID: engine.syncID}};
_("Fake applyIncoming to abort.");
engine._store.applyIncoming = function(record) {
engine._store.applyIncoming = async function(record) {
let ex = {code: Engine.prototype.eEngineAbortApplyIncoming,
cause: "Nooo"};
_("Throwing: " + JSON.stringify(ex));
@ -40,8 +40,8 @@ add_task(async function test_processIncoming_abort() {
_("Trying _processIncoming. It will throw after aborting.");
let err;
try {
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
} catch (ex) {
err = ex;
}
@ -52,7 +52,7 @@ add_task(async function test_processIncoming_abort() {
_("Trying engine.sync(). It will abort without error.");
try {
// This will quietly fail.
engine.sync();
await engine.sync();
} catch (ex) {
err = ex;
}

37
services/sync/tests/unit/test_engine_changes_during_sync.js
Просмотреть файл

@ -1,6 +1,5 @@
Cu.import("resource://gre/modules/FormHistory.jsm");
Cu.import("resource://gre/modules/Log.jsm");
Cu.import("resource://services-common/async.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/engines/bookmarks.js");
Cu.import("resource://services-sync/engines/history.js");
@ -30,7 +29,7 @@ async function assertChildGuids(folderGuid, expectedChildGuids, message) {
async function cleanup(engine, server) {
Svc.Obs.notify("weave:engine:stop-tracking");
engine._store.wipe();
await engine._store.wipe();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await promiseStopServer(server);
@ -49,14 +48,14 @@ add_task(async function test_history_change_during_sync() {
// Override `applyIncomingBatch` to insert a record while we're applying
// changes. The tracker should ignore this change.
let { applyIncomingBatch } = engine._store;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
_("Inserting local history visit");
engine._store.applyIncomingBatch = applyIncomingBatch;
let failed;
try {
Async.promiseSpinningly(addVisit("during_sync"));
await addVisit("during_sync");
} finally {
failed = applyIncomingBatch.call(this, records);
failed = await applyIncomingBatch.call(this, records);
}
return failed;
};
@ -105,7 +104,7 @@ add_task(async function test_passwords_change_during_sync() {
let collection = server.user("foo").collection("passwords");
let { applyIncomingBatch } = engine._store;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
_("Inserting local password");
engine._store.applyIncomingBatch = applyIncomingBatch;
let failed;
@ -114,7 +113,7 @@ add_task(async function test_passwords_change_during_sync() {
"password", "", "");
Services.logins.addLogin(login);
} finally {
failed = applyIncomingBatch.call(this, records);
failed = await applyIncomingBatch.call(this, records);
}
return failed;
};
@ -166,7 +165,7 @@ add_task(async function test_prefs_change_during_sync() {
let collection = server.user("foo").collection("prefs");
let { applyIncomingBatch } = engine._store;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
_("Updating local pref value");
engine._store.applyIncomingBatch = applyIncomingBatch;
let failed;
@ -174,7 +173,7 @@ add_task(async function test_prefs_change_during_sync() {
// Change the value of a synced pref.
Services.prefs.setCharPref(TEST_PREF, "hello");
} finally {
failed = applyIncomingBatch.call(this, records);
failed = await applyIncomingBatch.call(this, records);
}
return failed;
};
@ -227,12 +226,12 @@ add_task(async function test_forms_change_during_sync() {
let collection = server.user("foo").collection("forms");
let { applyIncomingBatch } = engine._store;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
_("Inserting local form history entry");
engine._store.applyIncomingBatch = applyIncomingBatch;
let failed;
try {
Async.promiseSpinningly(new Promise(resolve => {
await new Promise(resolve => {
FormHistory.update([{
op: "add",
fieldname: "favoriteDrink",
@ -240,9 +239,9 @@ add_task(async function test_forms_change_during_sync() {
}], {
handleCompletion: resolve,
});
}));
});
} finally {
failed = applyIncomingBatch.call(this, records);
failed = await applyIncomingBatch.call(this, records);
}
return failed;
};
@ -305,18 +304,18 @@ add_task(async function test_bookmark_change_during_sync() {
let bmk3; // New child of Folder 1, created locally during sync.
let { applyIncomingBatch } = engine._store;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
_("Inserting bookmark into local store");
engine._store.applyIncomingBatch = applyIncomingBatch;
let failed;
try {
bmk3 = Async.promiseSpinningly(PlacesUtils.bookmarks.insert({
bmk3 = await PlacesUtils.bookmarks.insert({
parentGuid: folder1.guid,
url: "https://mozilla.org/",
title: "Mozilla",
}));
});
} finally {
failed = applyIncomingBatch.call(this, records);
failed = await applyIncomingBatch.call(this, records);
}
return failed;
};
@ -399,7 +398,7 @@ add_task(async function test_bookmark_change_during_sync() {
let pingsPromise = wait_for_pings(2);
let changes = engine.pullNewChanges();
let changes = await engine.pullNewChanges();
deepEqual(Object.keys(changes).sort(), [
folder1.guid,
tbBmk.guid,
@ -441,7 +440,7 @@ add_task(async function test_bookmark_change_during_sync() {
equal(taggedURIs[0].spec, "https://example.org/",
"Synced tagged bookmark should appear in tagged URI list");
changes = engine.pullNewChanges();
changes = await engine.pullNewChanges();
deepEqual(changes, {},
"Should have already uploaded changes in follow-up sync");

52
services/sync/tests/unit/test_enginemanager.js
Просмотреть файл

@ -4,10 +4,6 @@
Cu.import("resource://services-sync/engines.js");
Cu.import("resource://services-sync/service.js");
function run_test() {
run_next_test();
}
function PetrolEngine() {}
PetrolEngine.prototype.name = "petrol";
PetrolEngine.prototype.finalize = async function() {};
@ -24,58 +20,58 @@ function ActualEngine() {}
ActualEngine.prototype = {__proto__: Engine.prototype,
name: "actual"};
add_test(function test_basics() {
add_task(async function test_basics() {
_("We start out with a clean slate");
let manager = new EngineManager(Service);
let engines = manager.getAll();
let engines = await manager.getAll();
do_check_eq(engines.length, 0);
do_check_eq(manager.get("dummy"), undefined);
do_check_eq((await manager.get("dummy")), undefined);
_("Register an engine");
manager.register(DummyEngine);
let dummy = manager.get("dummy");
await manager.register(DummyEngine);
let dummy = await manager.get("dummy");
do_check_true(dummy instanceof DummyEngine);
engines = manager.getAll();
engines = await manager.getAll();
do_check_eq(engines.length, 1);
do_check_eq(engines[0], dummy);
_("Register an already registered engine is ignored");
manager.register(DummyEngine);
do_check_eq(manager.get("dummy"), dummy);
await manager.register(DummyEngine);
do_check_eq((await manager.get("dummy")), dummy);
_("Register multiple engines in one go");
manager.register([PetrolEngine, DieselEngine]);
let petrol = manager.get("petrol");
let diesel = manager.get("diesel");
await manager.register([PetrolEngine, DieselEngine]);
let petrol = await manager.get("petrol");
let diesel = await manager.get("diesel");
do_check_true(petrol instanceof PetrolEngine);
do_check_true(diesel instanceof DieselEngine);
engines = manager.getAll();
engines = await manager.getAll();
do_check_eq(engines.length, 3);
do_check_neq(engines.indexOf(petrol), -1);
do_check_neq(engines.indexOf(diesel), -1);
_("Retrieve multiple engines in one go");
engines = manager.get(["dummy", "diesel"]);
engines = await manager.get(["dummy", "diesel"]);
do_check_eq(engines.length, 2);
do_check_neq(engines.indexOf(dummy), -1);
do_check_neq(engines.indexOf(diesel), -1);
_("getEnabled() only returns enabled engines");
engines = manager.getEnabled();
engines = await manager.getEnabled();
do_check_eq(engines.length, 0);
petrol.enabled = true;
engines = manager.getEnabled();
engines = await manager.getEnabled();
do_check_eq(engines.length, 1);
do_check_eq(engines[0], petrol);
dummy.enabled = true;
diesel.enabled = true;
engines = manager.getEnabled();
engines = await manager.getEnabled();
do_check_eq(engines.length, 3);
_("getEnabled() returns enabled engines in sorted order");
@ -83,7 +79,7 @@ add_test(function test_basics() {
dummy.syncPriority = 2;
diesel.syncPriority = 3;
engines = manager.getEnabled();
engines = await manager.getEnabled();
do_check_array_eq(engines, [petrol, dummy, diesel]);
@ -91,27 +87,25 @@ add_test(function test_basics() {
dummy.syncPriority = 4;
engines = manager.getEnabled();
engines = await manager.getEnabled();
do_check_array_eq(engines, [petrol, diesel, dummy]);
_("Unregister an engine by name");
manager.unregister("dummy");
do_check_eq(manager.get("dummy"), undefined);
engines = manager.getAll();
do_check_eq((await manager.get("dummy")), undefined);
engines = await manager.getAll();
do_check_eq(engines.length, 2);
do_check_eq(engines.indexOf(dummy), -1);
_("Unregister an engine by value");
// manager.unregister() checks for instanceof Engine, so let's make one:
manager.register(ActualEngine);
let actual = manager.get("actual");
await manager.register(ActualEngine);
let actual = await manager.get("actual");
do_check_true(actual instanceof ActualEngine);
do_check_true(actual instanceof Engine);
manager.unregister(actual);
do_check_eq(manager.get("actual"), undefined);
run_next_test();
do_check_eq((await manager.get("actual")), undefined);
});

228
services/sync/tests/unit/test_errorhandler_1.js
Просмотреть файл

@ -33,32 +33,29 @@ const PROLONGED_ERROR_DURATION =
const NON_PROLONGED_ERROR_DURATION =
(Svc.Prefs.get("errorhandler.networkFailureReportTimeout") / 2) * 1000;
Service.engineManager.clear();
function setLastSync(lastSyncValue) {
Svc.Prefs.set("lastSync", (new Date(Date.now() - lastSyncValue)).toString());
}
var engineManager = Service.engineManager;
engineManager.register(EHTestsCommon.CatapultEngine);
// This relies on Service/ErrorHandler being a singleton. Fixing this will take
// a lot of work.
var errorHandler = Service.errorHandler;
let errorHandler = Service.errorHandler;
let engine;
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
run_next_test();
}
Service.engineManager.clear();
await Service.engineManager.register(EHTestsCommon.CatapultEngine);
engine = Service.engineManager.get("catapult");
});
function clean() {
Service.startOver();
async function clean() {
await Service.startOver();
Status.resetSync();
Status.resetBackoff();
errorHandler.didReportProlongedError = false;
@ -67,7 +64,7 @@ function clean() {
add_task(async function test_401_logout() {
enableValidationPrefs();
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
@ -75,28 +72,21 @@ add_task(async function test_401_logout() {
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_true(Service.isLoggedIn);
let deferred = PromiseUtils.defer();
Svc.Obs.add("weave:service:sync:error", onSyncError);
function onSyncError() {
_("Got weave:service:sync:error in first sync.");
Svc.Obs.remove("weave:service:sync:error", onSyncError);
let promiseErrors = new Promise(res => {
Svc.Obs.add("weave:service:sync:error", onSyncError);
function onSyncError() {
_("Got weave:service:sync:error in first sync.");
Svc.Obs.remove("weave:service:sync:error", onSyncError);
// Wait for the automatic next sync.
function onLoginError() {
_("Got weave:service:login:error in second sync.");
Svc.Obs.remove("weave:service:login:error", onLoginError);
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
do_check_false(Service.isLoggedIn);
// Clean up.
Utils.nextTick(function() {
Service.startOver();
server.stop(deferred.resolve);
});
// Wait for the automatic next sync.
Svc.Obs.add("weave:service:login:error", onLoginError);
function onLoginError() {
_("Got weave:service:login:error in second sync.");
Svc.Obs.remove("weave:service:login:error", onLoginError);
res();
}
}
Svc.Obs.add("weave:service:login:error", onLoginError);
}
});
// Make sync fail due to login rejected.
await configureIdentity({username: "janedoe"}, server);
@ -106,13 +96,20 @@ add_task(async function test_401_logout() {
let ping = await sync_and_validate_telem(true);
deepEqual(ping.failureReason, { name: "httperror", code: 401 });
_("First sync done.");
await deferred.promise;
await promiseErrors;
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
do_check_false(Service.isLoggedIn);
// Clean up.
await Service.startOver();
await promiseStopServer(server);
});
add_task(async function test_credentials_changed_logout() {
enableValidationPrefs();
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
@ -133,7 +130,7 @@ add_task(async function test_credentials_changed_logout() {
do_check_false(Service.isLoggedIn);
// Clean up.
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -326,24 +323,24 @@ add_task(function test_shouldReportError() {
add_task(async function test_shouldReportError_master_password() {
_("Test error ignored due to locked master password");
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// Monkey patch Service.verifyLogin to imitate
// master password being locked.
Service._verifyLogin = Service.verifyLogin;
Service.verifyLogin = function() {
Service.verifyLogin = async function() {
Status.login = MASTER_PASSWORD_LOCKED;
return false;
};
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
do_check_false(errorHandler.shouldReportError());
// Clean up.
Service.verifyLogin = Service._verifyLogin;
clean();
await clean();
await promiseStopServer(server);
});
@ -369,7 +366,7 @@ add_task(async function test_login_syncAndReportErrors_non_network_error() {
// Test non-network errors are reported
// when calling syncAndReportErrors
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
Service.identity.resetSyncKeyBundle();
@ -380,7 +377,7 @@ add_task(async function test_login_syncAndReportErrors_non_network_error() {
await promiseObserved;
do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
clean();
await clean();
await promiseStopServer(server);
});
@ -389,11 +386,11 @@ add_task(async function test_sync_syncAndReportErrors_non_network_error() {
// Test non-network errors are reported
// when calling syncAndReportErrors
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_true(Service.isLoggedIn);
@ -412,8 +409,8 @@ add_task(async function test_sync_syncAndReportErrors_non_network_error() {
do_check_eq(Status.sync, CREDENTIALS_CHANGED);
// If we clean this tick, telemetry won't get the right error
await promiseNextTick();
clean();
await Async.promiseYield();
await clean();
await promiseStopServer(server);
});
@ -422,7 +419,7 @@ add_task(async function test_login_syncAndReportErrors_prolonged_non_network_err
// Test prolonged, non-network errors are
// reported when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
Service.identity.resetSyncKeyBundle();
@ -433,7 +430,7 @@ add_task(async function test_login_syncAndReportErrors_prolonged_non_network_err
await promiseObserved;
do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
clean();
await clean();
await promiseStopServer(server);
});
@ -442,11 +439,11 @@ add_task(async function test_sync_syncAndReportErrors_prolonged_non_network_erro
// Test prolonged, non-network errors are
// reported when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_true(Service.isLoggedIn);
@ -465,8 +462,8 @@ add_task(async function test_sync_syncAndReportErrors_prolonged_non_network_erro
do_check_eq(Status.sync, CREDENTIALS_CHANGED);
// If we clean this tick, telemetry won't get the right error
await promiseNextTick();
clean();
await Async.promiseYield();
await clean();
await promiseStopServer(server);
});
@ -485,27 +482,25 @@ add_task(async function test_login_syncAndReportErrors_network_error() {
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
clean();
await clean();
});
add_test(function test_sync_syncAndReportErrors_network_error() {
add_task(async function test_sync_syncAndReportErrors_network_error() {
enableValidationPrefs();
// Test network errors are reported when calling syncAndReportErrors.
Services.io.offline = true;
Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
Svc.Obs.remove("weave:ui:sync:error", onSyncError);
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
Services.io.offline = false;
clean();
run_next_test();
});
let promiseUISyncError = promiseOneObserver("weave:ui:sync:error");
setLastSync(NON_PROLONGED_ERROR_DURATION);
errorHandler.syncAndReportErrors();
await promiseUISyncError;
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
Services.io.offline = false;
await clean();
});
add_task(async function test_login_syncAndReportErrors_prolonged_network_error() {
@ -524,46 +519,44 @@ add_task(async function test_login_syncAndReportErrors_prolonged_network_error()
await promiseObserved;
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
clean();
await clean();
});
add_test(function test_sync_syncAndReportErrors_prolonged_network_error() {
add_task(async function test_sync_syncAndReportErrors_prolonged_network_error() {
enableValidationPrefs();
// Test prolonged, network errors are reported
// when calling syncAndReportErrors.
Services.io.offline = true;
Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
Svc.Obs.remove("weave:ui:sync:error", onSyncError);
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
Services.io.offline = false;
clean();
run_next_test();
});
let promiseUISyncError = promiseOneObserver("weave:ui:sync:error");
setLastSync(PROLONGED_ERROR_DURATION);
errorHandler.syncAndReportErrors();
await promiseUISyncError;
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
Services.io.offline = false;
await clean();
});
add_task(async function test_login_prolonged_non_network_error() {
enableValidationPrefs();
// Test prolonged, non-network errors are reported
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
Service.identity.resetSyncKeyBundle();
let promiseObserved = promiseOneObserver("weave:ui:login:error");
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -571,11 +564,11 @@ add_task(async function test_sync_prolonged_non_network_error() {
enableValidationPrefs();
// Test prolonged, non-network errors are reported
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_true(Service.isLoggedIn);
@ -594,7 +587,7 @@ add_task(async function test_sync_prolonged_non_network_error() {
await promiseObserved;
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -608,51 +601,49 @@ add_task(async function test_login_prolonged_network_error() {
let promiseObserved = promiseOneObserver("weave:ui:login:error");
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
});
add_test(function test_sync_prolonged_network_error() {
add_task(async function test_sync_prolonged_network_error() {
enableValidationPrefs();
// Test prolonged, network errors are reported
Services.io.offline = true;
Svc.Obs.add("weave:ui:sync:error", function onSyncError() {
Svc.Obs.remove("weave:ui:sync:error", onSyncError);
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
Services.io.offline = false;
clean();
run_next_test();
});
let promiseUISyncError = promiseOneObserver("weave:ui:sync:error");
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseUISyncError;
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
Services.io.offline = false;
await clean();
});
add_task(async function test_login_non_network_error() {
enableValidationPrefs();
// Test non-network errors are reported
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
Service.identity.resetSyncKeyBundle();
let promiseObserved = promiseOneObserver("weave:ui:login:error");
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -660,11 +651,11 @@ add_task(async function test_sync_non_network_error() {
enableValidationPrefs();
// Test non-network errors are reported
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
// By calling sync, we ensure we're logged in.
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_true(Service.isLoggedIn);
@ -673,12 +664,12 @@ add_task(async function test_sync_non_network_error() {
let promiseObserved = promiseOneObserver("weave:ui:sync:error");
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.sync, CREDENTIALS_CHANGED);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -692,44 +683,41 @@ add_task(async function test_login_network_error() {
// Test network errors are not reported.
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
do_check_false(errorHandler.didReportProlongedError);
Services.io.offline = false;
clean();
await clean();
});
add_test(function test_sync_network_error() {
add_task(async function test_sync_network_error() {
enableValidationPrefs();
// Test network errors are not reported.
Services.io.offline = true;
Svc.Obs.add("weave:ui:sync:finish", function onUIUpdate() {
Svc.Obs.remove("weave:ui:sync:finish", onUIUpdate);
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_false(errorHandler.didReportProlongedError);
Services.io.offline = false;
clean();
run_next_test();
});
let promiseSyncFinished = promiseOneObserver("weave:ui:sync:finish");
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseSyncFinished;
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_false(errorHandler.didReportProlongedError);
Services.io.offline = false;
await clean();
});
add_task(async function test_sync_server_maintenance_error() {
enableValidationPrefs();
// Test server maintenance errors are not reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
const BACKOFF = 42;
let engine = engineManager.get("catapult");
engine.enabled = true;
engine.exception = {status: 503,
headers: {"retry-after": BACKOFF}};
@ -753,7 +741,7 @@ add_task(async function test_sync_server_maintenance_error() {
do_check_eq(Status.sync, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -761,7 +749,7 @@ add_task(async function test_info_collections_login_server_maintenance_error() {
enableValidationPrefs();
// Test info/collections server maintenance errors are not reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.info"}, server);
@ -783,7 +771,7 @@ add_task(async function test_info_collections_login_server_maintenance_error() {
let promiseObserved = promiseOneObserver("weave:ui:clear-error")
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -793,7 +781,7 @@ add_task(async function test_info_collections_login_server_maintenance_error() {
do_check_false(errorHandler.didReportProlongedError);
Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
clean();
await clean();
await promiseStopServer(server);
});
@ -801,7 +789,7 @@ add_task(async function test_meta_global_login_server_maintenance_error() {
enableValidationPrefs();
// Test meta/global server maintenance errors are not reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.meta"}, server);
@ -823,7 +811,7 @@ add_task(async function test_meta_global_login_server_maintenance_error() {
let promiseObserved = promiseOneObserver("weave:ui:clear-error");
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -833,6 +821,6 @@ add_task(async function test_meta_global_login_server_maintenance_error() {
do_check_false(errorHandler.didReportProlongedError);
Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
clean();
await clean();
await promiseStopServer(server);
});

239
services/sync/tests/unit/test_errorhandler_2.js
Просмотреть файл

@ -32,32 +32,29 @@ const PROLONGED_ERROR_DURATION =
const NON_PROLONGED_ERROR_DURATION =
(Svc.Prefs.get("errorhandler.networkFailureReportTimeout") / 2) * 1000;
Service.engineManager.clear();
function setLastSync(lastSyncValue) {
Svc.Prefs.set("lastSync", (new Date(Date.now() - lastSyncValue)).toString());
}
var engineManager = Service.engineManager;
engineManager.register(EHTestsCommon.CatapultEngine);
// This relies on Service/ErrorHandler being a singleton. Fixing this will take
// a lot of work.
var errorHandler = Service.errorHandler;
let engine;
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
run_next_test();
}
Service.engineManager.clear();
await Service.engineManager.register(EHTestsCommon.CatapultEngine);
engine = Service.engineManager.get("catapult");
});
function clean() {
Service.startOver();
async function clean() {
await Service.startOver();
Status.resetSync();
Status.resetBackoff();
errorHandler.didReportProlongedError = false;
@ -68,7 +65,7 @@ add_task(async function test_crypto_keys_login_server_maintenance_error() {
Status.resetSync();
// Test crypto/keys server maintenance errors are not reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.keys"}, server);
@ -93,7 +90,7 @@ add_task(async function test_crypto_keys_login_server_maintenance_error() {
let promiseObserved = promiseOneObserver("weave:ui:clear-error");
setLastSync(NON_PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -103,7 +100,7 @@ add_task(async function test_crypto_keys_login_server_maintenance_error() {
do_check_false(errorHandler.didReportProlongedError);
Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
clean();
await clean();
await promiseStopServer(server);
});
@ -111,11 +108,10 @@ add_task(async function test_sync_prolonged_server_maintenance_error() {
enableValidationPrefs();
// Test prolonged server maintenance errors are reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
const BACKOFF = 42;
let engine = engineManager.get("catapult");
engine.enabled = true;
engine.exception = {status: 503,
headers: {"retry-after": BACKOFF}};
@ -136,14 +132,14 @@ add_task(async function test_sync_prolonged_server_maintenance_error() {
do_check_true(errorHandler.didReportProlongedError);
await promiseStopServer(server);
clean();
await clean();
});
add_task(async function test_info_collections_login_prolonged_server_maintenance_error() {
enableValidationPrefs();
// Test info/collections prolonged server maintenance errors are reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.info"}, server);
@ -160,7 +156,7 @@ add_task(async function test_info_collections_login_prolonged_server_maintenance
do_check_eq(Status.service, STATUS_OK);
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -169,7 +165,7 @@ add_task(async function test_info_collections_login_prolonged_server_maintenance
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -177,7 +173,7 @@ add_task(async function test_meta_global_login_prolonged_server_maintenance_erro
enableValidationPrefs();
// Test meta/global prolonged server maintenance errors are reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.meta"}, server);
@ -194,7 +190,7 @@ add_task(async function test_meta_global_login_prolonged_server_maintenance_erro
do_check_eq(Status.service, STATUS_OK);
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -203,7 +199,7 @@ add_task(async function test_meta_global_login_prolonged_server_maintenance_erro
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -211,7 +207,7 @@ add_task(async function test_download_crypto_keys_login_prolonged_server_mainten
enableValidationPrefs();
// Test crypto/keys prolonged server maintenance errors are reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.keys"}, server);
@ -230,7 +226,7 @@ add_task(async function test_download_crypto_keys_login_prolonged_server_mainten
do_check_eq(Status.service, STATUS_OK);
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
do_check_eq(backoffInterval, 42);
@ -238,7 +234,7 @@ add_task(async function test_download_crypto_keys_login_prolonged_server_mainten
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -246,7 +242,7 @@ add_task(async function test_upload_crypto_keys_login_prolonged_server_maintenan
enableValidationPrefs();
// Test crypto/keys prolonged server maintenance errors are reported.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.keys"}, server);
@ -263,7 +259,7 @@ add_task(async function test_upload_crypto_keys_login_prolonged_server_maintenan
do_check_eq(Status.service, STATUS_OK);
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -272,7 +268,7 @@ add_task(async function test_upload_crypto_keys_login_prolonged_server_maintenan
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -281,7 +277,7 @@ add_task(async function test_wipeServer_login_prolonged_server_maintenance_error
// Test that we report prolonged server maintenance errors that occur whilst
// wiping the server.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.wipe"}, server);
@ -298,7 +294,7 @@ add_task(async function test_wipeServer_login_prolonged_server_maintenance_error
do_check_eq(Status.service, STATUS_OK);
setLastSync(PROLONGED_ERROR_DURATION);
Service.sync();
await Service.sync();
await promiseObserved;
do_check_true(Status.enforceBackoff);
@ -307,7 +303,7 @@ add_task(async function test_wipeServer_login_prolonged_server_maintenance_error
do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
do_check_true(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -316,13 +312,12 @@ add_task(async function test_wipeRemote_prolonged_server_maintenance_error() {
// Test that we report prolonged server maintenance errors that occur whilst
// wiping all remote devices.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
server.registerPathHandler("/1.1/broken.wipe/storage/catapult", EHTestsCommon.service_unavailable);
await configureIdentity({username: "broken.wipe"}, server);
EHTestsCommon.generateAndUploadKeys();
let engine = engineManager.get("catapult");
engine.exception = null;
engine.enabled = true;
@ -350,7 +345,7 @@ add_task(async function test_wipeRemote_prolonged_server_maintenance_error() {
do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
do_check_true(errorHandler.didReportProlongedError);
await promiseStopServer(server);
clean();
await clean();
});
add_task(async function test_sync_syncAndReportErrors_server_maintenance_error() {
@ -358,11 +353,10 @@ add_task(async function test_sync_syncAndReportErrors_server_maintenance_error()
// Test server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
const BACKOFF = 42;
let engine = engineManager.get("catapult");
engine.enabled = true;
engine.exception = {status: 503,
headers: {"retry-after": BACKOFF}};
@ -379,7 +373,7 @@ add_task(async function test_sync_syncAndReportErrors_server_maintenance_error()
do_check_eq(Status.sync, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -388,7 +382,7 @@ add_task(async function test_info_collections_login_syncAndReportErrors_server_m
// Test info/collections server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.info"}, server);
@ -414,7 +408,7 @@ add_task(async function test_info_collections_login_syncAndReportErrors_server_m
do_check_eq(Status.login, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -423,7 +417,7 @@ add_task(async function test_meta_global_login_syncAndReportErrors_server_mainte
// Test meta/global server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.meta"}, server);
@ -449,7 +443,7 @@ add_task(async function test_meta_global_login_syncAndReportErrors_server_mainte
do_check_eq(Status.login, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -458,7 +452,7 @@ add_task(async function test_download_crypto_keys_login_syncAndReportErrors_serv
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.keys"}, server);
@ -486,7 +480,7 @@ add_task(async function test_download_crypto_keys_login_syncAndReportErrors_serv
do_check_eq(Status.login, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -495,7 +489,7 @@ add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_server
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.keys"}, server);
@ -521,7 +515,7 @@ add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_server
do_check_eq(Status.login, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -530,7 +524,7 @@ add_task(async function test_wipeServer_login_syncAndReportErrors_server_mainten
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.wipe"}, server);
@ -556,7 +550,7 @@ add_task(async function test_wipeServer_login_syncAndReportErrors_server_mainten
do_check_eq(Status.login, SERVER_MAINTENANCE);
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -565,12 +559,11 @@ add_task(async function test_wipeRemote_syncAndReportErrors_server_maintenance_e
// Test that we report prolonged server maintenance errors that occur whilst
// wiping all remote devices.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await configureIdentity({username: "broken.wipe"}, server);
EHTestsCommon.generateAndUploadKeys();
let engine = engineManager.get("catapult");
engine.exception = null;
engine.enabled = true;
@ -597,7 +590,7 @@ add_task(async function test_wipeRemote_syncAndReportErrors_server_maintenance_e
do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -606,11 +599,10 @@ add_task(async function test_sync_syncAndReportErrors_prolonged_server_maintenan
// Test prolonged server maintenance errors are
// reported when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
const BACKOFF = 42;
let engine = engineManager.get("catapult");
engine.enabled = true;
engine.exception = {status: 503,
headers: {"retry-after": BACKOFF}};
@ -629,7 +621,7 @@ add_task(async function test_sync_syncAndReportErrors_prolonged_server_maintenan
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -638,7 +630,7 @@ add_task(async function test_info_collections_login_syncAndReportErrors_prolonge
// Test info/collections server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.info"}, server);
@ -666,7 +658,7 @@ add_task(async function test_info_collections_login_syncAndReportErrors_prolonge
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -675,7 +667,7 @@ add_task(async function test_meta_global_login_syncAndReportErrors_prolonged_ser
// Test meta/global server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.meta"}, server);
@ -703,7 +695,7 @@ add_task(async function test_meta_global_login_syncAndReportErrors_prolonged_ser
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -712,7 +704,7 @@ add_task(async function test_download_crypto_keys_login_syncAndReportErrors_prol
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
await EHTestsCommon.setUp(server);
await configureIdentity({username: "broken.keys"}, server);
@ -742,7 +734,7 @@ add_task(async function test_download_crypto_keys_login_syncAndReportErrors_prol
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -751,7 +743,7 @@ add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_prolon
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.keys"}, server);
@ -779,7 +771,7 @@ add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_prolon
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
@ -788,7 +780,7 @@ add_task(async function test_wipeServer_login_syncAndReportErrors_prolonged_serv
// Test crypto/keys server maintenance errors are reported
// when calling syncAndReportErrors.
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
// Start off with an empty account, do not upload a key.
await configureIdentity({username: "broken.wipe"}, server);
@ -816,18 +808,16 @@ add_task(async function test_wipeServer_login_syncAndReportErrors_prolonged_serv
// didReportProlongedError not touched.
do_check_false(errorHandler.didReportProlongedError);
clean();
await clean();
await promiseStopServer(server);
});
add_task(async function test_sync_engine_generic_fail() {
enableValidationPrefs();
let server = EHTestsCommon.sync_httpd_setup();
let engine = engineManager.get("catapult");
let server = await EHTestsCommon.sync_httpd_setup();
engine.enabled = true;
engine.sync = function sync() {
engine.sync = async function sync() {
Svc.Obs.notify("weave:engine:sync:error", ENGINE_UNKNOWN_FAIL, "catapult");
};
@ -836,36 +826,14 @@ let engine = engineManager.get("catapult");
do_check_eq(Status.engines["catapult"], undefined);
let deferred = PromiseUtils.defer();
// Don't wait for reset-file-log until the sync is underway.
// This avoids us catching a delayed notification from an earlier test.
Svc.Obs.add("weave:engine:sync:finish", function onEngineFinish() {
Svc.Obs.remove("weave:engine:sync:finish", onEngineFinish);
let promiseObserved = new Promise(res => {
Svc.Obs.add("weave:engine:sync:finish", function onEngineFinish() {
Svc.Obs.remove("weave:engine:sync:finish", onEngineFinish);
log.info("Adding reset-file-log observer.");
Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
// Put these checks here, not after sync(), so that we aren't racing the
// log handler... which resets everything just a few lines below!
_("Status.engines: " + JSON.stringify(Status.engines));
do_check_eq(Status.engines["catapult"], ENGINE_UNKNOWN_FAIL);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
// Test Error log was written on SYNC_FAILED_PARTIAL.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
clean();
let syncErrors = sumHistogram("WEAVE_ENGINE_SYNC_ERRORS", { key: "catapult" });
do_check_true(syncErrors, 1);
server.stop(() => {
clean();
deferred.resolve();
log.info("Adding reset-file-log observer.");
Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
res();
});
});
});
@ -875,10 +843,28 @@ let engine = engineManager.get("catapult");
deepEqual(ping.status.service, SYNC_FAILED_PARTIAL);
deepEqual(ping.engines.find(e => e.status).status, ENGINE_UNKNOWN_FAIL);
await deferred.promise;
await promiseObserved;
_("Status.engines: " + JSON.stringify(Status.engines));
do_check_eq(Status.engines["catapult"], ENGINE_UNKNOWN_FAIL);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
// Test Error log was written on SYNC_FAILED_PARTIAL.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
await clean();
let syncErrors = sumHistogram("WEAVE_ENGINE_SYNC_ERRORS", { key: "catapult" });
do_check_true(syncErrors, 1);
await clean();
await promiseStopServer(server);
});
add_test(function test_logs_on_sync_error_despite_shouldReportError() {
add_task(async function test_logs_on_sync_error_despite_shouldReportError() {
enableValidationPrefs();
_("Ensure that an error is still logged when weave:service:sync:error " +
@ -892,22 +878,20 @@ add_test(function test_logs_on_sync_error_despite_shouldReportError() {
Status.login = MASTER_PASSWORD_LOCKED;
do_check_false(errorHandler.shouldReportError());
Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
// Test that error log was written.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
clean();
run_next_test();
});
let promiseObserved = promiseOneObserver("weave:service:reset-file-log");
Svc.Obs.notify("weave:service:sync:error", {});
await promiseObserved;
// Test that error log was written.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
await clean();
});
add_test(function test_logs_on_login_error_despite_shouldReportError() {
add_task(async function test_logs_on_login_error_despite_shouldReportError() {
enableValidationPrefs();
_("Ensure that an error is still logged when weave:service:login:error " +
@ -921,19 +905,17 @@ add_test(function test_logs_on_login_error_despite_shouldReportError() {
Status.login = MASTER_PASSWORD_LOCKED;
do_check_false(errorHandler.shouldReportError());
Svc.Obs.add("weave:service:reset-file-log", function onResetFileLog() {
Svc.Obs.remove("weave:service:reset-file-log", onResetFileLog);
// Test that error log was written.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
clean();
run_next_test();
});
let promiseObserved = promiseOneObserver("weave:service:reset-file-log");
Svc.Obs.notify("weave:service:login:error", {});
await promiseObserved;
// Test that error log was written.
let entries = logsdir.directoryEntries;
do_check_true(entries.hasMoreElements());
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
await clean();
});
// This test should be the last one since it monkeypatches the engine object
@ -941,12 +923,11 @@ add_test(function test_logs_on_login_error_despite_shouldReportError() {
add_task(async function test_engine_applyFailed() {
enableValidationPrefs();
let server = EHTestsCommon.sync_httpd_setup();
let server = await EHTestsCommon.sync_httpd_setup();
let engine = engineManager.get("catapult");
engine.enabled = true;
delete engine.exception;
engine.sync = function sync() {
engine.sync = async function sync() {
Svc.Obs.notify("weave:engine:sync:applied", {newFailed: 1}, "catapult");
};
@ -956,7 +937,7 @@ add_task(async function test_engine_applyFailed() {
do_check_eq(Status.engines["catapult"], undefined);
do_check_true(await EHTestsCommon.setUp(server));
Service.sync();
await Service.sync();
await promiseObserved;
do_check_eq(Status.engines["catapult"], ENGINE_APPLY_FAIL);
@ -968,6 +949,6 @@ add_task(async function test_engine_applyFailed() {
let logfile = entries.getNext().QueryInterface(Ci.nsILocalFile);
do_check_true(logfile.leafName.startsWith("error-sync-"), logfile.leafName);
clean();
await clean();
await promiseStopServer(server);
});

6
services/sync/tests/unit/test_errorhandler_eol.js
Просмотреть файл

@ -72,7 +72,7 @@ add_task(async function test_200_hard() {
let promiseObserved = promiseOneObserver("weave:eol");
Service._fetchInfo();
await Service._fetchInfo();
Service.scheduler.adjustSyncInterval(); // As if we failed or succeeded in syncing.
let { subject } = await promiseObserved;
@ -92,7 +92,7 @@ add_task(async function test_513_hard() {
let promiseObserved = promiseOneObserver("weave:eol");
try {
Service._fetchInfo();
await Service._fetchInfo();
Service.scheduler.adjustSyncInterval(); // As if we failed or succeeded in syncing.
} catch (ex) {
// Because fetchInfo will fail on a 513.
@ -114,7 +114,7 @@ add_task(async function test_200_soft() {
let promiseObserved = promiseOneObserver("weave:eol");
Service._fetchInfo();
await Service._fetchInfo();
Service.scheduler.adjustSyncInterval(); // As if we failed or succeeded in syncing.
let { subject } = await promiseObserved;
do_check_eq("soft-eol", subject.code);

66
services/sync/tests/unit/test_errorhandler_sync_checkServerError.js
Просмотреть файл

@ -22,12 +22,12 @@ function CatapultEngine() {
CatapultEngine.prototype = {
__proto__: SyncEngine.prototype,
exception: null, // tests fill this in
_sync: function _sync() {
async _sync() {
throw this.exception;
}
};
function sync_httpd_setup() {
async function sync_httpd_setup() {
let collectionsHelper = track_collections_helper();
let upd = collectionsHelper.with_updated_collection;
@ -65,12 +65,16 @@ async function generateAndUploadKeys(server) {
return (await serverKeys.upload(res)).success;
}
add_task(async function run_test() {
validate_all_future_pings();
await engineManager.register(CatapultEngine);
});
add_task(async function test_backoff500() {
enableValidationPrefs();
_("Test: HTTP 500 sets backoff status.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
let engine = engineManager.get("catapult");
@ -83,14 +87,14 @@ add_task(async function test_backoff500() {
// Forcibly create and upload keys here -- otherwise we don't get to the 500!
do_check_true(await generateAndUploadKeys(server));
Service.login();
Service.sync();
await Service.login();
await Service.sync();
do_check_true(Status.enforceBackoff);
do_check_eq(Status.sync, SYNC_SUCCEEDED);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
} finally {
Status.resetBackoff();
Service.startOver();
await Service.startOver();
}
await promiseStopServer(server);
});
@ -99,7 +103,7 @@ add_task(async function test_backoff503() {
enableValidationPrefs();
_("Test: HTTP 503 with Retry-After header leads to backoff notification and sets backoff status.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
const BACKOFF = 42;
@ -118,8 +122,8 @@ add_task(async function test_backoff503() {
do_check_true(await generateAndUploadKeys(server));
Service.login();
Service.sync();
await Service.login();
await Service.sync();
do_check_true(Status.enforceBackoff);
do_check_eq(backoffInterval, BACKOFF);
@ -128,7 +132,7 @@ add_task(async function test_backoff503() {
} finally {
Status.resetBackoff();
Status.resetSync();
Service.startOver();
await Service.startOver();
}
await promiseStopServer(server);
});
@ -137,7 +141,7 @@ add_task(async function test_overQuota() {
enableValidationPrefs();
_("Test: HTTP 400 with body error code 14 means over quota.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
let engine = engineManager.get("catapult");
@ -152,14 +156,14 @@ add_task(async function test_overQuota() {
do_check_true(await generateAndUploadKeys(server));
Service.login();
Service.sync();
await Service.login();
await Service.sync();
do_check_eq(Status.sync, OVER_QUOTA);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
} finally {
Status.resetSync();
Service.startOver();
await Service.startOver();
}
await promiseStopServer(server);
});
@ -168,7 +172,7 @@ add_task(async function test_service_networkError() {
enableValidationPrefs();
_("Test: Connection refused error from Service.sync() leads to the right status code.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
await promiseStopServer(server);
// Provoke connection refused.
@ -178,13 +182,13 @@ add_task(async function test_service_networkError() {
do_check_eq(Status.sync, SYNC_SUCCEEDED);
Service._loggedIn = true;
Service.sync();
await Service.sync();
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_eq(Status.service, SYNC_FAILED);
} finally {
Status.resetSync();
Service.startOver();
await Service.startOver();
}
});
@ -192,7 +196,7 @@ add_task(async function test_service_offline() {
enableValidationPrefs();
_("Test: Wanting to sync in offline mode leads to the right status code but does not increment the ignorable error count.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
await promiseStopServer(server);
@ -203,13 +207,13 @@ add_task(async function test_service_offline() {
do_check_eq(Status.sync, SYNC_SUCCEEDED);
Service._loggedIn = true;
Service.sync();
await Service.sync();
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_eq(Status.service, SYNC_FAILED);
} finally {
Status.resetSync();
Service.startOver();
await Service.startOver();
}
Services.io.offline = false;
Services.prefs.clearUserPref("network.dns.offline-localhost");
@ -219,7 +223,7 @@ add_task(async function test_engine_networkError() {
enableValidationPrefs();
_("Test: Network related exceptions from engine.sync() lead to the right status code.");
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
let engine = engineManager.get("catapult");
@ -232,14 +236,14 @@ add_task(async function test_engine_networkError() {
do_check_true(await generateAndUploadKeys(server));
Service.login();
Service.sync();
await Service.login();
await Service.sync();
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
} finally {
Status.resetSync();
Service.startOver();
await Service.startOver();
}
await promiseStopServer(server);
});
@ -247,7 +251,7 @@ add_task(async function test_engine_networkError() {
add_task(async function test_resource_timeout() {
enableValidationPrefs();
let server = sync_httpd_setup();
let server = await sync_httpd_setup();
await setUp(server);
let engine = engineManager.get("catapult");
@ -261,20 +265,14 @@ add_task(async function test_resource_timeout() {
do_check_true(await generateAndUploadKeys(server));
Service.login();
Service.sync();
await Service.login();
await Service.sync();
do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
} finally {
Status.resetSync();
Service.startOver();
await Service.startOver();
}
await promiseStopServer(server);
});
function run_test() {
validate_all_future_pings();
engineManager.register(CatapultEngine);
run_next_test();
}

12
services/sync/tests/unit/test_extension_storage_engine.js
Просмотреть файл

@ -11,10 +11,7 @@ Cu.import("resource://testing-common/services/sync/utils.js");
Cu.import("resource://gre/modules/ExtensionStorageSync.jsm");
/* globals extensionStorageSync */
Service.engineManager.register(ExtensionStorageEngine);
const engine = Service.engineManager.get("extension-storage");
do_get_profile(); // so we can use FxAccounts
loadWebExtensionTestFunctions();
let engine;
function mock(options) {
let calls = [];
@ -31,6 +28,13 @@ function mock(options) {
return ret;
}
add_task(async function setup() {
await Service.engineManager.register(ExtensionStorageEngine);
engine = Service.engineManager.get("extension-storage");
do_get_profile(); // so we can use FxAccounts
loadWebExtensionTestFunctions();
});
add_task(async function test_calling_sync_calls__sync() {
let oldSync = ExtensionStorageEngine.prototype._sync;
let syncMock = ExtensionStorageEngine.prototype._sync = mock({returns: true});

12
services/sync/tests/unit/test_extension_storage_tracker.js
Просмотреть файл

@ -11,10 +11,14 @@ Cu.import("resource://services-sync/util.js");
Cu.import("resource://gre/modules/ExtensionStorageSync.jsm");
/* globals extensionStorageSync */
Service.engineManager.register(ExtensionStorageEngine);
const engine = Service.engineManager.get("extension-storage");
do_get_profile(); // so we can use FxAccounts
loadWebExtensionTestFunctions();
let engine;
add_task(async function setup() {
await Service.engineManager.register(ExtensionStorageEngine);
engine = Service.engineManager.get("extension-storage");
do_get_profile(); // so we can use FxAccounts
loadWebExtensionTestFunctions();
});
add_task(async function test_changing_extension_storage_changes_score() {
const tracker = engine._tracker;

12
services/sync/tests/unit/test_form_validator.js
Просмотреть файл

@ -54,21 +54,19 @@ function getDummyServerAndClient() {
};
}
add_test(function test_valid() {
add_task(async function test_valid() {
let { server, client } = getDummyServerAndClient();
let validator = new FormValidator();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 3);
equal(records.length, 3)
equal(deletedRecords.length, 0);
deepEqual(problemData, validator.emptyProblemData());
run_next_test();
});
add_test(function test_formValidatorIgnoresMissingClients() {
add_task(async function test_formValidatorIgnoresMissingClients() {
// Since history form records are not deleted from the server, the
// |FormValidator| shouldn't set the |missingClient| flag in |problemData|.
let { server, client } = getDummyServerAndClient();
@ -76,7 +74,7 @@ add_test(function test_formValidatorIgnoresMissingClients() {
let validator = new FormValidator();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 2);
equal(records.length, 3);
@ -84,8 +82,6 @@ add_test(function test_formValidatorIgnoresMissingClients() {
let expected = validator.emptyProblemData();
deepEqual(problemData, expected);
run_next_test();
});
function run_test() {

69
services/sync/tests/unit/test_forms_store.js
Просмотреть файл

@ -7,22 +7,23 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://gre/modules/Services.jsm");
function run_test() {
add_task(async function run_test() {
let engine = new FormEngine(Service);
await engine.initialize();
let store = engine._store;
function applyEnsureNoFailures(records) {
do_check_eq(store.applyIncomingBatch(records).length, 0);
async function applyEnsureNoFailures(records) {
do_check_eq((await store.applyIncomingBatch(records)).length, 0);
}
_("Remove any existing entries");
store.wipe();
if (store.getAllIDs().length) {
await store.wipe();
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
_("Add a form entry");
applyEnsureNoFailures([{
await applyEnsureNoFailures([{
id: Utils.makeGUID(),
name: "name!!",
value: "value??"
@ -30,42 +31,42 @@ function run_test() {
_("Should have 1 entry now");
let id = "";
for (let _id in store.getAllIDs()) {
for (let _id in (await store.getAllIDs())) {
if (id == "")
id = _id;
else
do_throw("Should have only gotten one!");
}
do_check_true(store.itemExists(id));
do_check_true((store.itemExists(id)));
_("Should be able to find this entry as a dupe");
do_check_eq(engine._findDupe({name: "name!!", value: "value??"}), id);
do_check_eq((await engine._findDupe({name: "name!!", value: "value??"})), id);
let rec = store.createRecord(id);
let rec = await store.createRecord(id);
_("Got record for id", id, rec);
do_check_eq(rec.name, "name!!");
do_check_eq(rec.value, "value??");
_("Create a non-existent id for delete");
do_check_true(store.createRecord("deleted!!").deleted);
do_check_true((await store.createRecord("deleted!!")).deleted);
_("Try updating.. doesn't do anything yet");
store.update({});
await store.update({});
_("Remove all entries");
store.wipe();
if (store.getAllIDs().length) {
await store.wipe();
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
_("Add another entry");
applyEnsureNoFailures([{
await applyEnsureNoFailures([{
id: Utils.makeGUID(),
name: "another",
value: "entry"
}]);
id = "";
for (let _id in store.getAllIDs()) {
for (let _id in (await store.getAllIDs())) {
if (id == "")
id = _id;
else
@ -73,24 +74,24 @@ function run_test() {
}
_("Change the id of the new entry to something else");
store.changeItemID(id, "newid");
await store.changeItemID(id, "newid");
_("Make sure it's there");
do_check_true(store.itemExists("newid"));
do_check_true((store.itemExists("newid")));
_("Remove the entry");
store.remove({
await store.remove({
id: "newid"
});
if (store.getAllIDs().length) {
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
_("Removing the entry again shouldn't matter");
store.remove({
await store.remove({
id: "newid"
});
if (store.getAllIDs().length) {
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
@ -100,33 +101,33 @@ function run_test() {
name: "todelete",
value: "entry"
};
applyEnsureNoFailures([toDelete]);
await applyEnsureNoFailures([toDelete]);
id = "";
for (let _id in store.getAllIDs()) {
for (let _id in (await store.getAllIDs())) {
if (id == "")
id = _id;
else
do_throw("Should have only gotten one!");
}
do_check_true(store.itemExists(id));
do_check_true((store.itemExists(id)));
// mark entry as deleted
toDelete.id = id;
toDelete.deleted = true;
applyEnsureNoFailures([toDelete]);
if (store.getAllIDs().length) {
await applyEnsureNoFailures([toDelete]);
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
_("Add an entry to wipe");
applyEnsureNoFailures([{
await applyEnsureNoFailures([{
id: Utils.makeGUID(),
name: "towipe",
value: "entry"
}]);
store.wipe();
await store.wipe();
if (store.getAllIDs().length) {
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
@ -134,17 +135,17 @@ function run_test() {
Services.prefs.setBoolPref("browser.formfill.enable", false);
try {
// a search
if (store.getAllIDs().length) {
if ((await store.getAllIDs()).length) {
do_throw("Shouldn't get any ids!");
}
// an update.
applyEnsureNoFailures([{
await applyEnsureNoFailures([{
id: Utils.makeGUID(),
name: "some",
value: "entry"
}]);
} finally {
Services.prefs.clearUserPref("browser.formfill.enable");
store.wipe();
await store.wipe();
}
}
});

35
services/sync/tests/unit/test_forms_tracker.js
Просмотреть файл

@ -6,9 +6,10 @@ Cu.import("resource://services-sync/engines/forms.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
function run_test() {
add_task(async function run_test() {
_("Verify we've got an empty tracker to work with.");
let engine = new FormEngine(Service);
await engine.initialize();
let tracker = engine._tracker;
// Don't do asynchronous writes.
tracker.persistChangedIDs = false;
@ -16,28 +17,28 @@ function run_test() {
do_check_empty(tracker.changedIDs);
Log.repository.rootLogger.addAppender(new Log.DumpAppender());
function addEntry(name, value) {
engine._store.create({name, value});
async function addEntry(name, value) {
await engine._store.create({name, value});
}
function removeEntry(name, value) {
let guid = engine._findDupe({name, value});
engine._store.remove({id: guid});
async function removeEntry(name, value) {
let guid = await engine._findDupe({name, value});
await engine._store.remove({id: guid});
}
try {
_("Create an entry. Won't show because we haven't started tracking yet");
addEntry("name", "John Doe");
await addEntry("name", "John Doe");
do_check_empty(tracker.changedIDs);
_("Tell the tracker to start tracking changes.");
Svc.Obs.notify("weave:engine:start-tracking");
removeEntry("name", "John Doe");
addEntry("email", "john@doe.com");
await removeEntry("name", "John Doe");
await addEntry("email", "john@doe.com");
do_check_attribute_count(tracker.changedIDs, 2);
_("Notifying twice won't do any harm.");
Svc.Obs.notify("weave:engine:start-tracking");
addEntry("address", "Memory Lane");
await addEntry("address", "Memory Lane");
do_check_attribute_count(tracker.changedIDs, 3);
@ -45,9 +46,9 @@ function run_test() {
tracker.clearChangedIDs();
tracker.score = 0;
tracker.ignoreAll = true;
addEntry("username", "johndoe123");
addEntry("favoritecolor", "green");
removeEntry("name", "John Doe");
await addEntry("username", "johndoe123");
await addEntry("favoritecolor", "green");
await removeEntry("name", "John Doe");
tracker.ignoreAll = false;
do_check_empty(tracker.changedIDs);
equal(tracker.score, 0);
@ -55,18 +56,18 @@ function run_test() {
_("Let's stop tracking again.");
tracker.clearChangedIDs();
Svc.Obs.notify("weave:engine:stop-tracking");
removeEntry("address", "Memory Lane");
await removeEntry("address", "Memory Lane");
do_check_empty(tracker.changedIDs);
_("Notifying twice won't do any harm.");
Svc.Obs.notify("weave:engine:stop-tracking");
removeEntry("email", "john@doe.com");
await removeEntry("email", "john@doe.com");
do_check_empty(tracker.changedIDs);
} finally {
_("Clean up.");
engine._store.wipe();
await engine._store.wipe();
}
}
});

39
services/sync/tests/unit/test_fxa_node_reassignment.js
Просмотреть файл

@ -18,11 +18,7 @@ Cu.import("resource://services-sync/browserid_identity.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Cu.import("resource://gre/modules/PromiseUtils.jsm");
// Disables all built-in engines. Important for avoiding errors thrown by the
// add-ons engine.
Service.engineManager.clear();
function run_test() {
add_task(async function setup() {
Log.repository.getLogger("Sync.AsyncResource").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Resource").level = Log.Level.Trace;
@ -31,6 +27,10 @@ function run_test() {
Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
initTestLogging();
// Disables all built-in engines. Important for avoiding errors thrown by the
// add-ons engine.
Service.engineManager.clear();
// Setup the FxA identity manager and cluster manager.
Status.__authManager = Service.identity = new BrowserIDManager();
Service._clusterManager = Service.identity.createClusterManager(Service);
@ -41,9 +41,7 @@ function run_test() {
}
Svc.Obs.add("weave:ui:login:error", onUIError);
Svc.Obs.add("weave:ui:sync:error", onUIError);
run_next_test();
}
});
// API-compatible with SyncServer handler. Bind `handler` to something to use
@ -122,7 +120,7 @@ async function syncAndExpectNodeReassignment(server, firstNotification, between,
secondNotification, url) {
_("Starting syncAndExpectNodeReassignment\n");
let deferred = PromiseUtils.defer();
function onwards() {
async function onwards() {
let numTokenRequestsBefore;
function onFirstSync() {
_("First sync completed.");
@ -147,13 +145,14 @@ async function syncAndExpectNodeReassignment(server, firstNotification, between,
waitForZeroTimer(function() {
_("Second sync nextTick.");
do_check_eq(numTokenRequests, numTokenRequestsBefore + 1, "fetched a new token");
Service.startOver();
server.stop(deferred.resolve);
Service.startOver().then(() => {
server.stop(deferred.resolve);
});
});
}
Svc.Obs.add(firstNotification, onFirstSync);
Service.sync();
await Service.sync();
}
// Make sure that we really do get a 401 (but we can only do that if we are
@ -196,14 +195,14 @@ add_task(async function test_single_token_fetch() {
let server = await prepareServer(afterTokenFetch);
do_check_false(Service.isLoggedIn, "not already logged in");
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED, "sync succeeded");
do_check_eq(numTokenFetches, 0, "didn't fetch a new token");
// A bit hacky, but given we know how prepareServer works we can deduce
// that clusterURL we expect.
let expectedClusterURL = server.baseURI + "1.1/johndoe/";
do_check_eq(Service.clusterURL, expectedClusterURL);
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -215,7 +214,7 @@ add_task(async function test_momentary_401_engine() {
let john = server.user("johndoe");
_("Enabling the Rotary engine.");
let { engine, tracker } = registerRotaryEngine();
let { engine, tracker } = await registerRotaryEngine();
// We need the server to be correctly set up prior to experimenting. Do this
// through a sync.
@ -226,7 +225,7 @@ add_task(async function test_momentary_401_engine() {
john.createCollection("meta").insert("global", global);
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
_("Setting up Rotary collection to 401.");
let rotary = john.createCollection("rotary");
@ -270,7 +269,7 @@ add_task(async function test_momentary_401_info_collections_loggedin() {
let server = await prepareServer();
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
_("Arrange for info/collections to return a 401.");
let oldHandler = server.toplevelHandlers.info;
@ -317,12 +316,12 @@ add_task(async function test_momentary_401_info_collections_loggedout() {
do_check_false(Service.isLoggedIn, "not already logged in");
Service.sync();
await Service.sync();
do_check_eq(Status.sync, SYNC_SUCCEEDED, "sync succeeded");
// sync was successful - check we grabbed a new token.
do_check_true(sawTokenFetch, "a new token was fetched by this test.")
// and we are done.
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -335,7 +334,7 @@ add_task(async function test_momentary_401_storage_loggedin() {
let server = await prepareServer();
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
_("Arrange for meta/global to return a 401.");
let oldHandler = server.toplevelHandlers.storage;

203
services/sync/tests/unit/test_history_store.js
Просмотреть файл

@ -33,45 +33,36 @@ function queryHistoryVisits(uri) {
return queryPlaces(uri, options);
}
function onNextVisit(callback) {
PlacesUtils.history.addObserver({
onBeginUpdateBatch: function onBeginUpdateBatch() {},
onEndUpdateBatch: function onEndUpdateBatch() {},
onPageChanged: function onPageChanged() {},
onTitleChanged: function onTitleChanged() {
},
onVisit: function onVisit() {
PlacesUtils.history.removeObserver(this);
Utils.nextTick(callback);
},
onDeleteVisits: function onDeleteVisits() {},
onPageExpired: function onPageExpired() {},
onDeleteURI: function onDeleteURI() {},
onClearHistory: function onClearHistory() {},
QueryInterface: XPCOMUtils.generateQI([
Ci.nsINavHistoryObserver,
Ci.nsINavHistoryObserver_MOZILLA_1_9_1_ADDITIONS,
Ci.nsISupportsWeakReference
])
}, true);
function promiseOnVisitObserved() {
return new Promise(res => {
PlacesUtils.history.addObserver({
onBeginUpdateBatch: function onBeginUpdateBatch() {},
onEndUpdateBatch: function onEndUpdateBatch() {},
onPageChanged: function onPageChanged() {},
onTitleChanged: function onTitleChanged() {
},
onVisit: function onVisit() {
PlacesUtils.history.removeObserver(this);
res();
},
onDeleteVisits: function onDeleteVisits() {},
onPageExpired: function onPageExpired() {},
onDeleteURI: function onDeleteURI() {},
onClearHistory: function onClearHistory() {},
QueryInterface: XPCOMUtils.generateQI([
Ci.nsINavHistoryObserver,
Ci.nsINavHistoryObserver_MOZILLA_1_9_1_ADDITIONS,
Ci.nsISupportsWeakReference
])
}, true);
});
}
// Ensure exceptions from inside callbacks leads to test failures while
// we still clean up properly.
function ensureThrows(func) {
return function() {
try {
func.apply(this, arguments);
} catch (ex) {
PlacesTestUtils.clearHistory();
do_throw(ex);
}
};
}
var store = new HistoryEngine(Service)._store;
function applyEnsureNoFailures(records) {
do_check_eq(store.applyIncomingBatch(records).length, 0);
var engine = new HistoryEngine(Service);
Async.promiseSpinningly(engine.initialize());
var store = engine._store;
async function applyEnsureNoFailures(records) {
do_check_eq((await store.applyIncomingBatch(records)).length, 0);
}
var fxuri, fxguid, tburi, tbguid;
@ -81,95 +72,100 @@ function run_test() {
run_next_test();
}
add_test(function test_store() {
add_task(async function test_store() {
_("Verify that we've got an empty store to work with.");
do_check_empty(store.getAllIDs());
do_check_empty((await store.getAllIDs()));
_("Let's create an entry in the database.");
fxuri = Utils.makeURI("http://getfirefox.com/");
PlacesTestUtils.addVisits({ uri: fxuri, title: "Get Firefox!",
visitDate: TIMESTAMP1 })
.then(() => {
_("Verify that the entry exists.");
let ids = Object.keys(store.getAllIDs());
do_check_eq(ids.length, 1);
fxguid = ids[0];
do_check_true(store.itemExists(fxguid));
await PlacesTestUtils.addVisits({ uri: fxuri, title: "Get Firefox!",
visitDate: TIMESTAMP1 });
_("Verify that the entry exists.");
let ids = Object.keys((await store.getAllIDs()));
do_check_eq(ids.length, 1);
fxguid = ids[0];
do_check_true((await store.itemExists(fxguid)));
_("If we query a non-existent record, it's marked as deleted.");
let record = store.createRecord("non-existent");
do_check_true(record.deleted);
_("If we query a non-existent record, it's marked as deleted.");
let record = await store.createRecord("non-existent");
do_check_true(record.deleted);
_("Verify createRecord() returns a complete record.");
record = store.createRecord(fxguid);
do_check_eq(record.histUri, fxuri.spec);
do_check_eq(record.title, "Get Firefox!");
do_check_eq(record.visits.length, 1);
do_check_eq(record.visits[0].date, TIMESTAMP1);
do_check_eq(record.visits[0].type, Ci.nsINavHistoryService.TRANSITION_LINK);
_("Verify createRecord() returns a complete record.");
record = await store.createRecord(fxguid);
do_check_eq(record.histUri, fxuri.spec);
do_check_eq(record.title, "Get Firefox!");
do_check_eq(record.visits.length, 1);
do_check_eq(record.visits[0].date, TIMESTAMP1);
do_check_eq(record.visits[0].type, Ci.nsINavHistoryService.TRANSITION_LINK);
_("Let's modify the record and have the store update the database.");
let secondvisit = {date: TIMESTAMP2,
type: Ci.nsINavHistoryService.TRANSITION_TYPED};
onNextVisit(ensureThrows(function() {
let queryres = queryHistoryVisits(fxuri);
do_check_eq(queryres.length, 2);
do_check_eq(queryres[0].time, TIMESTAMP1);
do_check_eq(queryres[0].title, "Hol Dir Firefox!");
do_check_eq(queryres[1].time, TIMESTAMP2);
do_check_eq(queryres[1].title, "Hol Dir Firefox!");
run_next_test();
}));
applyEnsureNoFailures([
{id: fxguid,
histUri: record.histUri,
title: "Hol Dir Firefox!",
visits: [record.visits[0], secondvisit]}
]);
});
_("Let's modify the record and have the store update the database.");
let secondvisit = {date: TIMESTAMP2,
type: Ci.nsINavHistoryService.TRANSITION_TYPED};
let onVisitObserved = promiseOnVisitObserved();
await applyEnsureNoFailures([
{id: fxguid,
histUri: record.histUri,
title: "Hol Dir Firefox!",
visits: [record.visits[0], secondvisit]}
]);
await onVisitObserved;
try {
let queryres = queryHistoryVisits(fxuri);
do_check_eq(queryres.length, 2);
do_check_eq(queryres[0].time, TIMESTAMP1);
do_check_eq(queryres[0].title, "Hol Dir Firefox!");
do_check_eq(queryres[1].time, TIMESTAMP2);
do_check_eq(queryres[1].title, "Hol Dir Firefox!");
} catch (ex) {
PlacesTestUtils.clearHistory();
do_throw(ex);
}
});
add_test(function test_store_create() {
add_task(async function test_store_create() {
_("Create a brand new record through the store.");
tbguid = Utils.makeGUID();
tburi = Utils.makeURI("http://getthunderbird.com");
onNextVisit(ensureThrows(function() {
do_check_attribute_count(store.getAllIDs(), 2);
let queryres = queryHistoryVisits(tburi);
do_check_eq(queryres.length, 1);
do_check_eq(queryres[0].time, TIMESTAMP3);
do_check_eq(queryres[0].title, "The bird is the word!");
run_next_test();
}));
applyEnsureNoFailures([
let onVisitObserved = promiseOnVisitObserved();
await applyEnsureNoFailures([
{id: tbguid,
histUri: tburi.spec,
title: "The bird is the word!",
visits: [{date: TIMESTAMP3,
type: Ci.nsINavHistoryService.TRANSITION_TYPED}]}
]);
await onVisitObserved;
try {
do_check_attribute_count(Async.promiseSpinningly(store.getAllIDs()), 2);
let queryres = queryHistoryVisits(tburi);
do_check_eq(queryres.length, 1);
do_check_eq(queryres[0].time, TIMESTAMP3);
do_check_eq(queryres[0].title, "The bird is the word!");
} catch (ex) {
PlacesTestUtils.clearHistory();
do_throw(ex);
}
});
add_test(function test_null_title() {
add_task(async function test_null_title() {
_("Make sure we handle a null title gracefully (it can happen in some cases, e.g. for resource:// URLs)");
let resguid = Utils.makeGUID();
let resuri = Utils.makeURI("unknown://title");
applyEnsureNoFailures([
await applyEnsureNoFailures([
{id: resguid,
histUri: resuri.spec,
title: null,
visits: [{date: TIMESTAMP3,
type: Ci.nsINavHistoryService.TRANSITION_TYPED}]}
]);
do_check_attribute_count(store.getAllIDs(), 3);
do_check_attribute_count((await store.getAllIDs()), 3);
let queryres = queryHistoryVisits(resuri);
do_check_eq(queryres.length, 1);
do_check_eq(queryres[0].time, TIMESTAMP3);
run_next_test();
});
add_test(function test_invalid_records() {
add_task(async function test_invalid_records() {
_("Make sure we handle invalid URLs in places databases gracefully.");
let connection = PlacesUtils.history
.QueryInterface(Ci.nsPIPlacesDatabase)
@ -190,11 +186,11 @@ add_test(function test_invalid_records() {
);
Async.querySpinningly(stmt);
stmt.finalize();
do_check_attribute_count(store.getAllIDs(), 4);
do_check_attribute_count((await store.getAllIDs()), 4);
_("Make sure we report records with invalid URIs.");
let invalid_uri_guid = Utils.makeGUID();
let failed = store.applyIncomingBatch([{
let failed = await store.applyIncomingBatch([{
id: invalid_uri_guid,
histUri: ":::::::::::::::",
title: "Doesn't have a valid URI",
@ -205,7 +201,7 @@ add_test(function test_invalid_records() {
do_check_eq(failed[0], invalid_uri_guid);
_("Make sure we handle records with invalid GUIDs gracefully (ignore).");
applyEnsureNoFailures([
await applyEnsureNoFailures([
{id: "invalid",
histUri: "http://invalid.guid/",
title: "Doesn't have a valid GUID",
@ -218,7 +214,7 @@ add_test(function test_invalid_records() {
let no_type_visit_guid = Utils.makeGUID();
let invalid_type_visit_guid = Utils.makeGUID();
let non_integer_visit_guid = Utils.makeGUID();
failed = store.applyIncomingBatch([
failed = await store.applyIncomingBatch([
{id: no_date_visit_guid,
histUri: "http://no.date.visit/",
title: "Visit has no date",
@ -241,7 +237,7 @@ add_test(function test_invalid_records() {
do_check_eq(failed.length, 0);
_("Make sure we handle records with javascript: URLs gracefully.");
applyEnsureNoFailures([
await applyEnsureNoFailures([
{id: Utils.makeGUID(),
histUri: "javascript:''",
title: "javascript:''",
@ -250,32 +246,29 @@ add_test(function test_invalid_records() {
]);
_("Make sure we handle records without any visits gracefully.");
applyEnsureNoFailures([
await applyEnsureNoFailures([
{id: Utils.makeGUID(),
histUri: "http://getfirebug.com",
title: "Get Firebug!",
visits: []}
]);
run_next_test();
});
add_test(function test_remove() {
add_task(async function test_remove() {
_("Remove an existent record and a non-existent from the store.");
applyEnsureNoFailures([{id: fxguid, deleted: true},
await applyEnsureNoFailures([{id: fxguid, deleted: true},
{id: Utils.makeGUID(), deleted: true}]);
do_check_false(store.itemExists(fxguid));
do_check_false((await store.itemExists(fxguid)));
let queryres = queryHistoryVisits(fxuri);
do_check_eq(queryres.length, 0);
_("Make sure wipe works.");
store.wipe();
do_check_empty(store.getAllIDs());
await store.wipe();
do_check_empty((await store.getAllIDs()));
queryres = queryHistoryVisits(fxuri);
do_check_eq(queryres.length, 0);
queryres = queryHistoryVisits(tburi);
do_check_eq(queryres.length, 0);
run_next_test();
});
add_test(function cleanup() {

28
services/sync/tests/unit/test_history_tracker.js
Просмотреть файл

@ -9,33 +9,35 @@ Cu.import("resource://services-sync/engines/history.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Service.engineManager.clear();
Service.engineManager.register(HistoryEngine);
var engine = Service.engineManager.get("history");
var tracker = engine._tracker;
let engine;
let tracker;
// Don't write out by default.
tracker.persistChangedIDs = false;
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Tracker.History").level = Log.Level.Trace;
run_next_test();
}
Service.engineManager.clear();
await Service.engineManager.register(HistoryEngine);
engine = Service.engineManager.get("history");
tracker = engine._tracker;
// Don't write out by default.
tracker.persistChangedIDs = false;
});
async function verifyTrackerEmpty() {
let changes = engine.pullNewChanges();
let changes = await engine.pullNewChanges();
do_check_empty(changes);
equal(tracker.score, 0);
}
async function verifyTrackedCount(expected) {
let changes = engine.pullNewChanges();
let changes = await engine.pullNewChanges();
do_check_attribute_count(changes, expected);
}
async function verifyTrackedItems(tracked) {
let changes = engine.pullNewChanges();
let changes = await engine.pullNewChanges();
let trackedIDs = new Set(Object.keys(changes));
for (let guid of tracked) {
ok(guid in changes, `${guid} should be tracked`);

16
services/sync/tests/unit/test_hmac_error.js
Просмотреть файл

@ -11,19 +11,19 @@ Cu.import("resource://testing-common/services/sync/utils.js");
var hmacErrorCount = 0;
(function() {
let hHE = Service.handleHMACEvent;
Service.handleHMACEvent = function() {
Service.handleHMACEvent = async function() {
hmacErrorCount++;
return hHE.call(Service);
};
})();
function shared_setup() {
async function shared_setup() {
enableValidationPrefs();
hmacErrorCount = 0;
// Make sure RotaryEngine is the only one we sync.
let { engine, tracker } = registerRotaryEngine();
let { engine, tracker } = await registerRotaryEngine();
engine.lastSync = 123; // Needs to be non-zero so that tracker is queried.
engine._store.items = {flying: "LNER Class A3 4472",
scotsman: "Flying Scotsman"};
@ -46,7 +46,7 @@ function shared_setup() {
add_task(async function hmac_error_during_404() {
_("Attempt to replicate the HMAC error setup.");
let [engine, rotaryColl, clientsColl, keysWBO, global, tracker] = shared_setup();
let [engine, rotaryColl, clientsColl, keysWBO, global, tracker] = await shared_setup();
// Hand out 404s for crypto/keys.
let keysHandler = keysWBO.handler();
@ -75,7 +75,7 @@ add_task(async function hmac_error_during_404() {
let server = sync_httpd_setup(handlers);
// Do not instantiate SyncTestingInfrastructure; we need real crypto.
await configureIdentity({ username: "foo" }, server);
Service.login();
await Service.login();
try {
_("Syncing.");
@ -102,7 +102,7 @@ add_task(async function hmac_error_during_404() {
add_task(async function hmac_error_during_node_reassignment() {
_("Attempt to replicate an HMAC error during node reassignment.");
let [engine, rotaryColl, clientsColl, keysWBO, global, tracker] = shared_setup();
let [engine, rotaryColl, clientsColl, keysWBO, global, tracker] = await shared_setup();
let collectionsHelper = track_collections_helper();
let upd = collectionsHelper.with_updated_collection;
@ -180,7 +180,7 @@ add_task(async function hmac_error_during_node_reassignment() {
// source file to broadly follow actual execution order.
function onwards() {
_("== Invoking first sync.");
Service.sync();
Async.promiseSpinningly(Service.sync());
_("We should not simultaneously have data but no keys on the server.");
let hasData = rotaryColl.wbo("flying") ||
rotaryColl.wbo("scotsman");
@ -227,7 +227,7 @@ add_task(async function hmac_error_during_node_reassignment() {
server.stop(resolve);
};
Service.sync();
Async.promiseSpinningly(Service.sync());
},
this);
};

90
services/sync/tests/unit/test_interval_triggers.js
Просмотреть файл

@ -10,13 +10,8 @@ Cu.import("resource://testing-common/services/sync/utils.js");
Svc.Prefs.set("registerEngines", "");
Cu.import("resource://services-sync/service.js");
var scheduler = Service.scheduler;
var clientsEngine = Service.clientsEngine;
// Don't remove stale clients when syncing. This is a test-only workaround
// that lets us add clients directly to the store, without losing them on
// the next sync.
clientsEngine._removeRemoteClient = id => {};
let scheduler;
let clientsEngine;
function sync_httpd_setup() {
let global = new ServerWBO("global", {
@ -48,14 +43,20 @@ async function setUp(server) {
serverKeys.upload(Service.resource(Service.cryptoKeysURL));
}
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
run_next_test();
}
scheduler = Service.scheduler;
clientsEngine = Service.clientsEngine;
// Don't remove stale clients when syncing. This is a test-only workaround
// that lets us add clients directly to the store, without losing them on
// the next sync.
clientsEngine._removeRemoteClient = async (id) => {};
});
add_task(async function test_successful_sync_adjustSyncInterval() {
enableValidationPrefs();
@ -80,7 +81,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
_("Test as long as numClients <= 1 our sync interval is SINGLE_USER.");
// idle == true && numClients <= 1 && hasIncomingItems == false
scheduler.idle = true;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 1);
do_check_true(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -89,7 +90,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
// idle == false && numClients <= 1 && hasIncomingItems == false
scheduler.idle = false;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 2);
do_check_false(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -98,7 +99,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
// idle == false && numClients <= 1 && hasIncomingItems == true
scheduler.hasIncomingItems = true;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 3);
do_check_false(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -107,7 +108,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
// idle == true && numClients <= 1 && hasIncomingItems == true
scheduler.idle = true;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 4);
do_check_true(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -116,8 +117,8 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
_("Test as long as idle && numClients > 1 our sync interval is idleInterval.");
// idle == true && numClients > 1 && hasIncomingItems == true
Service.clientsEngine._store.create({ id: "foo", cleartext: { name: "bar", type: "mobile" } });
Service.sync();
await Service.clientsEngine._store.create({ id: "foo", cleartext: { name: "bar", type: "mobile" } });
await Service.sync();
do_check_eq(syncSuccesses, 5);
do_check_true(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -126,7 +127,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
// idle == true && numClients > 1 && hasIncomingItems == false
scheduler.hasIncomingItems = false;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 6);
do_check_true(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -136,7 +137,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
_("Test non-idle, numClients > 1, no incoming items => activeInterval.");
// idle == false && numClients > 1 && hasIncomingItems == false
scheduler.idle = false;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 7);
do_check_false(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -146,7 +147,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
_("Test non-idle, numClients > 1, incoming items => immediateInterval.");
// idle == false && numClients > 1 && hasIncomingItems == true
scheduler.hasIncomingItems = true;
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 8);
do_check_false(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -154,7 +155,7 @@ add_task(async function test_successful_sync_adjustSyncInterval() {
do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
Svc.Obs.remove("weave:service:sync:finish", onSyncFinish);
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -186,7 +187,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
_("Test as long as numClients <= 1 our sync interval is SINGLE_USER.");
// idle == true && numClients <= 1 && hasIncomingItems == false
scheduler.idle = true;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 1);
do_check_true(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -195,7 +196,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
// idle == false && numClients <= 1 && hasIncomingItems == false
scheduler.idle = false;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 2);
do_check_false(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -204,7 +205,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
// idle == false && numClients <= 1 && hasIncomingItems == true
scheduler.hasIncomingItems = true;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 3);
do_check_false(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -213,7 +214,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
// idle == true && numClients <= 1 && hasIncomingItems == true
scheduler.idle = true;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 4);
do_check_true(scheduler.idle);
do_check_false(scheduler.numClients > 1);
@ -225,7 +226,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
Svc.Prefs.set("clients.devices.mobile", 2);
scheduler.updateClientMode();
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 5);
do_check_true(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -234,7 +235,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
// idle == true && numClients > 1 && hasIncomingItems == false
scheduler.hasIncomingItems = false;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 6);
do_check_true(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -244,7 +245,7 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
_("Test non-idle, numClients > 1, no incoming items => activeInterval.");
// idle == false && numClients > 1 && hasIncomingItems == false
scheduler.idle = false;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 7);
do_check_false(scheduler.idle);
do_check_true(scheduler.numClients > 1);
@ -254,14 +255,14 @@ add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
_("Test non-idle, numClients > 1, incoming items => immediateInterval.");
// idle == false && numClients > 1 && hasIncomingItems == true
scheduler.hasIncomingItems = true;
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 8);
do_check_false(scheduler.idle);
do_check_true(scheduler.numClients > 1);
do_check_false(scheduler.hasIncomingItems); // gets reset to false
do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
Service.startOver();
await Service.startOver();
Svc.Obs.remove("weave:service:sync:error", onSyncError);
await promiseStopServer(server);
});
@ -291,9 +292,9 @@ add_task(async function test_back_triggers_sync() {
Service.recordManager.clearCache();
Svc.Prefs.resetBranch("");
scheduler.setDefaults();
clientsEngine.resetClient();
await clientsEngine.resetClient();
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -319,14 +320,14 @@ add_task(async function test_adjust_interval_on_sync_error() {
do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
Svc.Prefs.set("clients.devices.mobile", 2);
Service.sync();
await Service.sync();
do_check_eq(syncFailures, 1);
do_check_true(scheduler.numClients > 1);
do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
Svc.Obs.remove("weave:service:sync:error", onSyncError);
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -349,7 +350,7 @@ add_task(async function test_bug671378_scenario() {
Svc.Obs.add("weave:service:sync:finish", onSyncFinish);
// After first sync call, syncInterval & syncTimer are singleDeviceInterval.
Service.sync();
await Service.sync();
do_check_eq(syncSuccesses, 1);
do_check_false(scheduler.numClients > 1);
do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
@ -370,8 +371,9 @@ add_task(async function test_bug671378_scenario() {
scheduler.scheduleNextSync = scheduler._scheduleNextSync;
Svc.Obs.remove("weave:service:sync:finish", onSyncFinish);
Service.startOver();
server.stop(resolve);
Service.startOver().then(() => {
server.stop(resolve);
});
}
};
});
@ -393,12 +395,12 @@ add_task(async function test_bug671378_scenario() {
});
});
Service.clientsEngine._store.create({ id: "foo", cleartext: { name: "bar", type: "mobile" } });
Service.sync();
await Service.clientsEngine._store.create({ id: "foo", cleartext: { name: "bar", type: "mobile" } });
await Service.sync();
await promiseDone;
});
add_test(function test_adjust_timer_larger_syncInterval() {
add_task(async function test_adjust_timer_larger_syncInterval() {
_("Test syncInterval > current timout period && nextSync != 0, syncInterval is NOT used.");
Svc.Prefs.set("clients.devices.mobile", 2);
scheduler.updateClientMode();
@ -411,7 +413,7 @@ add_test(function test_adjust_timer_larger_syncInterval() {
do_check_eq(scheduler.syncTimer.delay, scheduler.activeInterval);
// Make interval large again
clientsEngine._wipeClient();
await clientsEngine._wipeClient();
Svc.Prefs.reset("clients.devices.mobile");
scheduler.updateClientMode();
do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
@ -423,11 +425,10 @@ add_test(function test_adjust_timer_larger_syncInterval() {
do_check_true(scheduler.syncTimer.delay <= scheduler.activeInterval);
// SyncSchedule.
Service.startOver();
run_next_test();
await Service.startOver();
});
add_test(function test_adjust_timer_smaller_syncInterval() {
add_task(async function test_adjust_timer_smaller_syncInterval() {
_("Test current timout > syncInterval period && nextSync != 0, syncInterval is used.");
scheduler.scheduleNextSync();
@ -447,6 +448,5 @@ add_test(function test_adjust_timer_smaller_syncInterval() {
do_check_true(scheduler.syncTimer.delay <= scheduler.activeInterval);
// SyncSchedule.
Service.startOver();
run_next_test();
await Service.startOver();
});

99
services/sync/tests/unit/test_node_reassignment.js
Просмотреть файл

@ -14,7 +14,8 @@ Cu.import("resource://testing-common/services/sync/rotaryengine.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Cu.import("resource://gre/modules/PromiseUtils.jsm");
function run_test() {
add_task(async function setup() {
Log.repository.getLogger("Sync.AsyncResource").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Resource").level = Log.Level.Trace;
@ -30,9 +31,7 @@ function run_test() {
}
Svc.Obs.add("weave:ui:login:error", onUIError);
Svc.Obs.add("weave:ui:sync:error", onUIError);
run_next_test();
}
});
/**
* Emulate the following Zeus config:
@ -95,42 +94,44 @@ async function syncAndExpectNodeReassignment(server, firstNotification, between,
};
Service.identity._tokenServerClient = mockTSC;
function onwards() {
function onFirstSync() {
_("First sync completed.");
Svc.Obs.remove(firstNotification, onFirstSync);
Svc.Obs.add(secondNotification, onSecondSync);
// Make sure that it works!
await new Promise(res => {
let request = new RESTRequest(url);
request.get(function() {
do_check_eq(request.response.status, 401);
res();
});
});
do_check_eq(Service.clusterURL, "");
function onFirstSync() {
_("First sync completed.");
Svc.Obs.remove(firstNotification, onFirstSync);
Svc.Obs.add(secondNotification, onSecondSync);
// Allow for tests to clean up error conditions.
between();
}
function onSecondSync() {
_("Second sync completed.");
Svc.Obs.remove(secondNotification, onSecondSync);
Service.scheduler.clearSyncTriggers();
do_check_eq(Service.clusterURL, "");
// Make absolutely sure that any event listeners are done with their work
// before we proceed.
waitForZeroTimer(function() {
_("Second sync nextTick.");
do_check_eq(getTokenCount, 1);
Service.startOver();
// Allow for tests to clean up error conditions.
between();
}
function onSecondSync() {
_("Second sync completed.");
Svc.Obs.remove(secondNotification, onSecondSync);
Service.scheduler.clearSyncTriggers();
// Make absolutely sure that any event listeners are done with their work
// before we proceed.
waitForZeroTimer(function() {
_("Second sync nextTick.");
do_check_eq(getTokenCount, 1);
Service.startOver().then(() => {
server.stop(deferred.resolve);
});
}
Svc.Obs.add(firstNotification, onFirstSync);
Service.sync();
});
}
// Make sure that it works!
let request = new RESTRequest(url);
request.get(function() {
do_check_eq(request.response.status, 401);
Utils.nextTick(onwards);
});
Svc.Obs.add(firstNotification, onFirstSync);
await Service.sync();
await deferred.promise;
}
@ -142,7 +143,7 @@ add_task(async function test_momentary_401_engine() {
let john = server.user("johndoe");
_("Enabling the Rotary engine.");
let { engine, tracker } = registerRotaryEngine();
let { engine, tracker } = await registerRotaryEngine();
// We need the server to be correctly set up prior to experimenting. Do this
// through a sync.
@ -153,7 +154,7 @@ add_task(async function test_momentary_401_engine() {
john.createCollection("meta").insert("global", global);
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
_("Setting up Rotary collection to 401.");
let rotary = john.createCollection("rotary");
@ -197,7 +198,7 @@ add_task(async function test_momentary_401_info_collections() {
let server = await prepareServer();
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
// Return a 401 for info requests, particularly info/collections.
let oldHandler = server.toplevelHandlers.info;
@ -223,7 +224,7 @@ add_task(async function test_momentary_401_storage_loggedin() {
let server = await prepareServer();
_("Performing initial sync to ensure we are logged in.")
Service.sync();
await Service.sync();
// Return a 401 for all storage requests.
let oldHandler = server.toplevelHandlers.storage;
@ -355,15 +356,16 @@ add_task(async function test_loop_avoidance_storage() {
_("Third sync nextTick.");
do_check_false(getReassigned());
do_check_eq(getTokenCount, 2);
Service.startOver();
server.stop(deferred.resolve);
Service.startOver().then(() => {
server.stop(deferred.resolve);
});
});
}
Svc.Obs.add(firstNotification, onFirstSync);
now = Date.now();
Service.sync();
await Service.sync();
await deferred.promise;
});
@ -376,7 +378,7 @@ add_task(async function test_loop_avoidance_engine() {
let john = server.user("johndoe");
_("Enabling the Rotary engine.");
let { engine, tracker } = registerRotaryEngine();
let { engine, tracker } = await registerRotaryEngine();
let deferred = PromiseUtils.defer();
let getTokenCount = 0;
@ -399,7 +401,7 @@ add_task(async function test_loop_avoidance_engine() {
john.createCollection("meta").insert("global", global);
_("First sync to prepare server contents.");
Service.sync();
await Service.sync();
_("Setting up Rotary collection to 401.");
let rotary = john.createCollection("rotary");
@ -420,12 +422,6 @@ add_task(async function test_loop_avoidance_engine() {
rotary.collectionHandler = oldHandler;
}
function afterSuccessfulSync() {
Svc.Obs.remove("weave:service:login:start", onLoginStart);
Service.startOver();
server.stop(deferred.resolve);
}
let firstNotification = "weave:service:sync:finish";
let secondNotification = "weave:service:sync:finish";
let thirdNotification = "weave:service:sync:finish";
@ -494,14 +490,17 @@ add_task(async function test_loop_avoidance_engine() {
_("Third sync nextTick.");
do_check_false(getReassigned());
do_check_eq(getTokenCount, 2);
afterSuccessfulSync();
Svc.Obs.remove("weave:service:login:start", onLoginStart);
Service.startOver().then(() => {
server.stop(deferred.resolve);
});
});
}
Svc.Obs.add(firstNotification, onFirstSync);
now = Date.now();
Service.sync();
await Service.sync();
await deferred.promise;
tracker.clearChangedIDs();

2
services/sync/tests/unit/test_password_engine.js
Просмотреть файл

@ -16,7 +16,7 @@ function run_test() {
async function cleanup(engine, server) {
Svc.Obs.notify("weave:engine:stop-tracking");
engine.wipeClient();
await engine.wipeClient();
Svc.Prefs.resetBranch("");
Service.recordManager.clearCache();
await promiseStopServer(server);

72
services/sync/tests/unit/test_password_store.js
Просмотреть файл

@ -6,7 +6,7 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
function checkRecord(name, record, expectedCount, timeCreated,
async function checkRecord(name, record, expectedCount, timeCreated,
expectedTimeCreated, timePasswordChanged,
expectedTimePasswordChanged, recordIsUpdated) {
let engine = Service.engineManager.get("passwords");
@ -22,7 +22,7 @@ function checkRecord(name, record, expectedCount, timeCreated,
do_check_eq(count.value, expectedCount);
if (expectedCount > 0) {
do_check_true(!!store.getAllIDs()[record.id]);
do_check_true(!!(await store.getAllIDs())[record.id]);
let stored_record = logins[0].QueryInterface(Ci.nsILoginMetaInfo);
if (timeCreated !== undefined) {
@ -38,15 +38,15 @@ function checkRecord(name, record, expectedCount, timeCreated,
return stored_record.timePasswordChanged;
}
} else {
do_check_true(!store.getAllIDs()[record.id]);
do_check_true(!(await store.getAllIDs())[record.id]);
}
return undefined;
}
function changePassword(name, hostname, password, expectedCount, timeCreated,
expectedTimeCreated, timePasswordChanged,
expectedTimePasswordChanged, insert, recordIsUpdated) {
async function changePassword(name, hostname, password, expectedCount, timeCreated,
expectedTimeCreated, timePasswordChanged,
expectedTimePasswordChanged, insert, recordIsUpdated) {
const BOGUS_GUID = "zzzzzz" + hostname;
@ -71,7 +71,7 @@ function changePassword(name, hostname, password, expectedCount, timeCreated,
let store = engine._store;
if (insert) {
do_check_eq(store.applyIncomingBatch([record]).length, 0);
do_check_eq((await store.applyIncomingBatch([record])).length, 0);
}
return checkRecord(name, record, expectedCount, timeCreated,
@ -81,42 +81,42 @@ function changePassword(name, hostname, password, expectedCount, timeCreated,
}
function test_apply_records_with_times(hostname, timeCreated, timePasswordChanged) {
async function test_apply_records_with_times(hostname, timeCreated, timePasswordChanged) {
// The following record is going to be inserted in the store and it needs
// to be found there. Then its timestamps are going to be compared to
// the expected values.
changePassword(" ", hostname, "password", 1, timeCreated, timeCreated,
await changePassword(" ", hostname, "password", 1, timeCreated, timeCreated,
timePasswordChanged, timePasswordChanged, true);
}
function test_apply_multiple_records_with_times() {
async function test_apply_multiple_records_with_times() {
// The following records are going to be inserted in the store and they need
// to be found there. Then their timestamps are going to be compared to
// the expected values.
changePassword("A", "http://foo.a.com", "password", 1, undefined, undefined,
await changePassword("A", "http://foo.a.com", "password", 1, undefined, undefined,
undefined, undefined, true);
changePassword("B", "http://foo.b.com", "password", 1, 1000, 1000, undefined,
await changePassword("B", "http://foo.b.com", "password", 1, 1000, 1000, undefined,
undefined, true);
changePassword("C", "http://foo.c.com", "password", 1, undefined, undefined,
await changePassword("C", "http://foo.c.com", "password", 1, undefined, undefined,
1000, 1000, true);
changePassword("D", "http://foo.d.com", "password", 1, 1000, 1000, 1000,
await changePassword("D", "http://foo.d.com", "password", 1, 1000, 1000, 1000,
1000, true);
// The following records are not going to be inserted in the store and they
// are not going to be found there.
changePassword("NotInStoreA", "http://foo.aaaa.com", "password", 0,
await changePassword("NotInStoreA", "http://foo.aaaa.com", "password", 0,
undefined, undefined, undefined, undefined, false);
changePassword("NotInStoreB", "http://foo.bbbb.com", "password", 0, 1000,
await changePassword("NotInStoreB", "http://foo.bbbb.com", "password", 0, 1000,
1000, undefined, undefined, false);
changePassword("NotInStoreC", "http://foo.cccc.com", "password", 0,
await changePassword("NotInStoreC", "http://foo.cccc.com", "password", 0,
undefined, undefined, 1000, 1000, false);
changePassword("NotInStoreD", "http://foo.dddd.com", "password", 0, 1000,
await changePassword("NotInStoreD", "http://foo.dddd.com", "password", 0, 1000,
1000, 1000, 1000, false);
}
function test_apply_same_record_with_different_times() {
async function test_apply_same_record_with_different_times() {
// The following record is going to be inserted multiple times in the store
// and it needs to be found there. Then its timestamps are going to be
// compared to the expected values.
@ -125,24 +125,24 @@ function test_apply_same_record_with_different_times() {
/* The eslint linter thinks that timePasswordChanged is unused, even though
it is passed as an argument to changePassword. */
var timePasswordChanged = 100;
timePasswordChanged = changePassword("A", "http://a.tn", "password", 1, 100,
timePasswordChanged = await changePassword("A", "http://a.tn", "password", 1, 100,
100, 100, timePasswordChanged, true);
timePasswordChanged = changePassword("A", "http://a.tn", "password", 1, 100,
timePasswordChanged = await changePassword("A", "http://a.tn", "password", 1, 100,
100, 800, timePasswordChanged, true,
true);
timePasswordChanged = changePassword("A", "http://a.tn", "password", 1, 500,
timePasswordChanged = await changePassword("A", "http://a.tn", "password", 1, 500,
100, 800, timePasswordChanged, true,
true);
timePasswordChanged = changePassword("A", "http://a.tn", "password2", 1, 500,
timePasswordChanged = await changePassword("A", "http://a.tn", "password2", 1, 500,
100, 1536213005222, timePasswordChanged,
true, true);
timePasswordChanged = changePassword("A", "http://a.tn", "password2", 1, 500,
timePasswordChanged = await changePassword("A", "http://a.tn", "password2", 1, 500,
100, 800, timePasswordChanged, true, true);
/* eslint-enable no-unsed-vars */
}
function run_test() {
add_task(async function run_test() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Engine.Passwords").level = Log.Level.Trace;
Log.repository.getLogger("Sync.Store.Passwords").level = Log.Level.Trace;
@ -169,7 +169,7 @@ function run_test() {
let store = engine._store;
try {
do_check_eq(store.applyIncomingBatch([recordA, recordB]).length, 0);
do_check_eq((await store.applyIncomingBatch([recordA, recordB])).length, 0);
// Only the good record makes it to Services.logins.
let badCount = {};
@ -187,19 +187,19 @@ function run_test() {
do_check_eq(goodCount.value, 1);
do_check_eq(badCount.value, 0);
do_check_true(!!store.getAllIDs()[BOGUS_GUID_B]);
do_check_true(!store.getAllIDs()[BOGUS_GUID_A]);
do_check_true(!!(await store.getAllIDs())[BOGUS_GUID_B]);
do_check_true(!(await store.getAllIDs())[BOGUS_GUID_A]);
test_apply_records_with_times("http://afoo.baz.com", undefined, undefined);
test_apply_records_with_times("http://bfoo.baz.com", 1000, undefined);
test_apply_records_with_times("http://cfoo.baz.com", undefined, 2000);
test_apply_records_with_times("http://dfoo.baz.com", 1000, 2000);
await test_apply_records_with_times("http://afoo.baz.com", undefined, undefined);
await test_apply_records_with_times("http://bfoo.baz.com", 1000, undefined);
await test_apply_records_with_times("http://cfoo.baz.com", undefined, 2000);
await test_apply_records_with_times("http://dfoo.baz.com", 1000, 2000);
test_apply_multiple_records_with_times();
await test_apply_multiple_records_with_times();
test_apply_same_record_with_different_times();
await test_apply_same_record_with_different_times();
} finally {
store.wipe();
await store.wipe();
}
}
});

32
services/sync/tests/unit/test_password_tracker.js
Просмотреть файл

@ -7,20 +7,22 @@ Cu.import("resource://services-sync/engines.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Service.engineManager.register(PasswordEngine);
var engine = Service.engineManager.get("passwords");
var store = engine._store;
var tracker = engine._tracker;
let engine;
let store;
let tracker;
// Don't do asynchronous writes.
tracker.persistChangedIDs = false;
function run_test() {
add_task(async function setup() {
initTestLogging("Trace");
run_next_test();
}
await Service.engineManager.register(PasswordEngine);
engine = Service.engineManager.get("passwords");
store = engine._store;
tracker = engine._tracker;
add_test(function test_tracking() {
// Don't do asynchronous writes.
tracker.persistChangedIDs = false;
});
add_task(async function test_tracking() {
let recordNum = 0;
_("Verify we've got an empty tracker to work with.");
@ -74,15 +76,14 @@ add_test(function test_tracking() {
} finally {
_("Clean up.");
store.wipe();
await store.wipe();
tracker.clearChangedIDs();
tracker.resetScore();
Svc.Obs.notify("weave:engine:stop-tracking");
run_next_test();
}
});
add_test(function test_onWipe() {
add_task(async function test_onWipe() {
_("Verify we've got an empty tracker to work with.");
do_check_empty(tracker.changedIDs);
do_check_eq(tracker.score, 0);
@ -90,12 +91,11 @@ add_test(function test_onWipe() {
try {
_("A store wipe should increment the score");
Svc.Obs.notify("weave:engine:start-tracking");
store.wipe();
await store.wipe();
do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
} finally {
tracker.resetScore();
Svc.Obs.notify("weave:engine:stop-tracking");
run_next_test();
}
});

20
services/sync/tests/unit/test_password_validator.js
Просмотреть файл

@ -80,20 +80,18 @@ function getDummyServerAndClient() {
}
add_test(function test_valid() {
add_task(async function test_valid() {
let { server, client } = getDummyServerAndClient();
let validator = new PasswordValidator();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 3);
equal(records.length, 3)
equal(deletedRecords.length, 0);
deepEqual(problemData, validator.emptyProblemData());
run_next_test();
});
add_test(function test_missing() {
add_task(async function test_missing() {
let validator = new PasswordValidator();
{
let { server, client } = getDummyServerAndClient();
@ -101,7 +99,7 @@ add_test(function test_missing() {
client.pop();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 2);
equal(records.length, 3)
@ -117,7 +115,7 @@ add_test(function test_missing() {
server.pop();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 3);
equal(records.length, 2)
@ -127,12 +125,10 @@ add_test(function test_missing() {
expected.serverMissing.push("33333");
deepEqual(problemData, expected);
}
run_next_test();
});
add_test(function test_deleted() {
add_task(async function test_deleted() {
let { server, client } = getDummyServerAndClient();
let deletionRecord = { id: "444444", guid: "444444", deleted: true };
@ -140,7 +136,7 @@ add_test(function test_deleted() {
let validator = new PasswordValidator();
let { problemData, clientRecords, records, deletedRecords } =
validator.compareClientWithServer(client, server);
await validator.compareClientWithServer(client, server);
equal(clientRecords.length, 3);
equal(records.length, 4);
@ -148,8 +144,6 @@ add_test(function test_deleted() {
let expected = validator.emptyProblemData();
deepEqual(problemData, expected);
run_next_test();
});

11
services/sync/tests/unit/test_places_guid_downgrade.js
Просмотреть файл

@ -86,8 +86,9 @@ add_test(function test_initial_state() {
run_next_test();
});
add_test(function test_history_guids() {
add_task(async function test_history_guids() {
let engine = new HistoryEngine(Service);
await engine.initialize();
let store = engine._store;
let places = [
@ -155,7 +156,7 @@ add_test(function test_history_guids() {
}
});
add_test(function test_bookmark_guids() {
add_task(async function test_bookmark_guids() {
let engine = new BookmarksEngine(Service);
let store = engine._store;
@ -170,8 +171,8 @@ add_test(function test_bookmark_guids() {
PlacesUtils.bookmarks.DEFAULT_INDEX,
"Get Thunderbird!");
let fxguid = store.GUIDForId(fxid);
let tbguid = store.GUIDForId(tbid);
let fxguid = await store.GUIDForId(fxid);
let tbguid = await store.GUIDForId(tbid);
_("Bookmarks: Verify GUIDs are added to the guid column.");
let connection = PlacesUtils.history
@ -203,8 +204,6 @@ add_test(function test_bookmark_guids() {
result = Async.querySpinningly(stmt, ["guid"]);
do_check_eq(result.length, 0);
stmt.finalize();
run_next_test();
});
function run_test() {

120
services/sync/tests/unit/test_postqueue.js
Просмотреть файл

@ -30,7 +30,7 @@ function makePostQueue(config, lastModTime, responseGenerator) {
return { pq, stats };
}
add_test(function test_simple() {
add_task(async function test_simple() {
let config = {
max_post_bytes: 1000,
max_post_records: 100,
@ -45,21 +45,19 @@ add_test(function test_simple() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
pq.enqueue(makeRecord(10));
pq.flush(true);
await pq.enqueue(makeRecord(10));
await pq.flush(true);
deepEqual(stats.posts, [{
nbytes: 12, // expect our 10 byte record plus "[]" to wrap it.
commit: true, // we don't know if we have batch semantics, so committed.
headers: [["x-if-unmodified-since", time]],
batch: "true"}]);
run_next_test();
});
// Test we do the right thing when we need to make multiple posts when there
// are no batch semantics
add_test(function test_max_post_bytes_no_batch() {
add_task(async function test_max_post_bytes_no_batch() {
let config = {
max_post_bytes: 50,
max_post_records: 4,
@ -74,10 +72,10 @@ add_test(function test_max_post_bytes_no_batch() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
pq.enqueue(makeRecord(20)); // total size now 22 bytes - "[" + record + "]"
pq.enqueue(makeRecord(20)); // total size now 43 bytes - "[" + record + "," + record + "]"
pq.enqueue(makeRecord(20)); // this will exceed our byte limit, so will be in the 2nd POST.
pq.flush(true);
await pq.enqueue(makeRecord(20)); // total size now 22 bytes - "[" + record + "]"
await pq.enqueue(makeRecord(20)); // total size now 43 bytes - "[" + record + "," + record + "]"
await pq.enqueue(makeRecord(20)); // this will exceed our byte limit, so will be in the 2nd POST.
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -93,12 +91,10 @@ add_test(function test_max_post_bytes_no_batch() {
}
]);
equal(pq.lastModified, time + 200);
run_next_test();
});
// Similar to the above, but we've hit max_records instead of max_bytes.
add_test(function test_max_post_records_no_batch() {
add_task(async function test_max_post_records_no_batch() {
let config = {
max_post_bytes: 100,
max_post_records: 2,
@ -114,10 +110,10 @@ add_test(function test_max_post_records_no_batch() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
pq.enqueue(makeRecord(20)); // total size now 22 bytes - "[" + record + "]"
pq.enqueue(makeRecord(20)); // total size now 43 bytes - "[" + record + "," + record + "]"
pq.enqueue(makeRecord(20)); // this will exceed our records limit, so will be in the 2nd POST.
pq.flush(true);
await pq.enqueue(makeRecord(20)); // total size now 22 bytes - "[" + record + "]"
await pq.enqueue(makeRecord(20)); // total size now 43 bytes - "[" + record + "," + record + "]"
await pq.enqueue(makeRecord(20)); // this will exceed our records limit, so will be in the 2nd POST.
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -133,14 +129,12 @@ add_test(function test_max_post_records_no_batch() {
}
]);
equal(pq.lastModified, time + 200);
run_next_test();
});
// Batch tests.
// Test making a single post when batch semantics are in place.
add_test(function test_single_batch() {
add_task(async function test_single_batch() {
let config = {
max_post_bytes: 1000,
max_post_records: 100,
@ -155,8 +149,8 @@ add_test(function test_single_batch() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
ok(pq.enqueue(makeRecord(10)).enqueued);
pq.flush(true);
ok((await pq.enqueue(makeRecord(10))).enqueued);
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -166,13 +160,11 @@ add_test(function test_single_batch() {
headers: [["x-if-unmodified-since", time]],
}
]);
run_next_test();
});
// Test we do the right thing when we need to make multiple posts when there
// are batch semantics in place.
add_test(function test_max_post_bytes_batch() {
add_task(async function test_max_post_bytes_batch() {
let config = {
max_post_bytes: 50,
max_post_records: 4,
@ -191,10 +183,10 @@ add_test(function test_max_post_bytes_batch() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 22 bytes - "[" + record + "]"
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
ok(pq.enqueue(makeRecord(20)).enqueued); // this will exceed our byte limit, so will be in the 2nd POST.
pq.flush(true);
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 22 bytes - "[" + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // this will exceed our byte limit, so will be in the 2nd POST.
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -211,12 +203,10 @@ add_test(function test_max_post_bytes_batch() {
]);
equal(pq.lastModified, time + 200);
run_next_test();
});
// Test we do the right thing when the batch bytes limit is exceeded.
add_test(function test_max_post_bytes_batch() {
add_task(async function test_max_post_bytes_batch() {
let config = {
max_post_bytes: 50,
max_post_records: 20,
@ -242,16 +232,16 @@ add_test(function test_max_post_bytes_batch() {
}
let { pq, stats } = makePostQueue(config, time0, responseGenerator());
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 22 bytes - "[" + record + "]"
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 22 bytes - "[" + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
// this will exceed our POST byte limit, so will be in the 2nd POST - but still in the first batch.
ok(pq.enqueue(makeRecord(20)).enqueued); // 22 bytes for 2nd post, 55 bytes in the batch.
ok((await pq.enqueue(makeRecord(20))).enqueued); // 22 bytes for 2nd post, 55 bytes in the batch.
// this will exceed our batch byte limit, so will be in a new batch.
ok(pq.enqueue(makeRecord(20)).enqueued); // 22 bytes in 3rd post/2nd batch
ok(pq.enqueue(makeRecord(20)).enqueued); // 43 bytes in 3rd post/2nd batch
ok((await pq.enqueue(makeRecord(20))).enqueued); // 22 bytes in 3rd post/2nd batch
ok((await pq.enqueue(makeRecord(20))).enqueued); // 43 bytes in 3rd post/2nd batch
// This will exceed POST byte limit, so will be in the 4th post, part of the 2nd batch.
ok(pq.enqueue(makeRecord(20)).enqueued); // 22 bytes for 4th post/2nd batch
pq.flush(true);
ok((await pq.enqueue(makeRecord(20))).enqueued); // 22 bytes for 4th post/2nd batch
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -281,13 +271,11 @@ add_test(function test_max_post_bytes_batch() {
]);
equal(pq.lastModified, time1 + 200);
run_next_test();
});
// Test we split up the posts when we exceed the record limit when batch semantics
// are in place.
add_test(function test_max_post_bytes_batch() {
add_task(async function test_max_post_bytes_batch() {
let config = {
max_post_bytes: 1000,
max_post_records: 2,
@ -306,10 +294,10 @@ add_test(function test_max_post_bytes_batch() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 22 bytes - "[" + record + "]"
ok(pq.enqueue(makeRecord(20)).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
ok(pq.enqueue(makeRecord(20)).enqueued); // will exceed record limit, so will be in 2nd post.
pq.flush(true);
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 22 bytes - "[" + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // total size now 43 bytes - "[" + record + "," + record + "]"
ok((await pq.enqueue(makeRecord(20))).enqueued); // will exceed record limit, so will be in 2nd post.
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -326,12 +314,10 @@ add_test(function test_max_post_bytes_batch() {
]);
equal(pq.lastModified, time + 200);
run_next_test();
});
// Test that a single huge record fails to enqueue
add_test(function test_huge_record() {
add_task(async function test_huge_record() {
let config = {
max_post_bytes: 50,
max_post_records: 100,
@ -350,18 +336,18 @@ add_test(function test_huge_record() {
}
let { pq, stats } = makePostQueue(config, time, responseGenerator());
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
let { enqueued, error } = pq.enqueue(makeRecord(1000));
let { enqueued, error } = await pq.enqueue(makeRecord(1000));
ok(!enqueued);
notEqual(error, undefined);
// make sure that we keep working, skipping the bad record entirely
// (handling the error the queue reported is left up to caller)
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
pq.flush(true);
await pq.flush(true);
deepEqual(stats.posts, [
{
@ -378,12 +364,10 @@ add_test(function test_huge_record() {
]);
equal(pq.lastModified, time + 200);
run_next_test();
});
// Test we do the right thing when the batch record limit is exceeded.
add_test(function test_max_records_batch() {
add_task(async function test_max_records_batch() {
let config = {
max_post_bytes: 1000,
max_post_records: 3,
@ -410,20 +394,20 @@ add_test(function test_max_records_batch() {
let { pq, stats } = makePostQueue(config, time0, responseGenerator());
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
ok(pq.enqueue(makeRecord(20)).enqueued);
ok((await pq.enqueue(makeRecord(20))).enqueued);
pq.flush(true);
await pq.flush(true);
deepEqual(stats.posts, [
{ // 3 records
@ -450,6 +434,4 @@ add_test(function test_max_records_batch() {
]);
equal(pq.lastModified, time1 + 200);
run_next_test();
});

31
services/sync/tests/unit/test_prefs_store.js
Просмотреть файл

@ -22,31 +22,32 @@ function makePersona(id) {
};
}
function run_test() {
add_task(async function run_test() {
_("Test fixtures.");
// read our custom prefs file before doing anything.
Services.prefs.readUserPrefsFromFile(do_get_file("prefs_test_prefs_store.js"));
let store = Service.engineManager.get("prefs")._store;
let engine = Service.engineManager.get("prefs");
let store = engine._store;
let prefs = new Preferences();
try {
_("The GUID corresponds to XUL App ID.");
let allIDs = store.getAllIDs();
let allIDs = await store.getAllIDs();
let ids = Object.keys(allIDs);
do_check_eq(ids.length, 1);
do_check_eq(ids[0], PREFS_GUID);
do_check_true(allIDs[PREFS_GUID], true);
do_check_true(store.itemExists(PREFS_GUID));
do_check_false(store.itemExists("random-gibberish"));
do_check_true((await store.itemExists(PREFS_GUID)));
do_check_false((await store.itemExists("random-gibberish")));
_("Unknown prefs record is created as deleted.");
let record = store.createRecord("random-gibberish", "prefs");
let record = await store.createRecord("random-gibberish", "prefs");
do_check_true(record.deleted);
_("Prefs record contains only prefs that should be synced.");
record = store.createRecord(PREFS_GUID, "prefs");
record = await store.createRecord(PREFS_GUID, "prefs");
do_check_eq(record.value["testing.int"], 123);
do_check_eq(record.value["testing.string"], "ohai");
do_check_eq(record.value["testing.bool"], true);
@ -78,7 +79,7 @@ function run_test() {
"testing.somepref": "im a new pref from other device",
"services.sync.prefs.sync.testing.somepref": true
};
store.update(record);
await store.update(record);
do_check_eq(prefs.get("testing.int"), 42);
do_check_eq(prefs.get("testing.string"), "im in ur prefs");
do_check_eq(prefs.get("testing.bool"), false);
@ -101,7 +102,7 @@ function run_test() {
"lightweightThemes.selectedThemeID": persona1.id,
"lightweightThemes.usedThemes": usedThemes
};
store.update(record);
await store.update(record);
do_check_eq(prefs.get("lightweightThemes.selectedThemeID"), persona1.id);
do_check_true(Utils.deepEquals(LightweightThemeManager.currentTheme,
persona1));
@ -111,7 +112,7 @@ function run_test() {
"lightweightThemes.selectedThemeID": null,
"lightweightThemes.usedThemes": usedThemes
};
store.update(record);
await store.update(record);
do_check_false(!!prefs.get("lightweightThemes.selectedThemeID"));
do_check_eq(LightweightThemeManager.currentTheme, null);
@ -120,7 +121,7 @@ function run_test() {
record.value = {
"testing.int": 98
};
store.update(record);
await store.update(record);
do_check_eq(prefs.get("testing.int"), 42);
_("The light-weight theme preference is handled correctly.");
@ -134,21 +135,21 @@ function run_test() {
record.value = {
"testing.int": 42,
};
store.update(record);
await store.update(record);
do_check_true(lastThemeID === undefined,
"should not have tried to change the theme with an unrelated pref.");
Services.prefs.setCharPref("lightweightThemes.selectedThemeID", "foo");
record.value = {
"lightweightThemes.selectedThemeID": "foo",
};
store.update(record);
await store.update(record);
do_check_true(lastThemeID === undefined,
"should not have tried to change the theme when the incoming pref matches current value.");
record.value = {
"lightweightThemes.selectedThemeID": "bar",
};
store.update(record);
await store.update(record);
do_check_eq(lastThemeID, "bar",
"should have tried to change the theme when the incoming pref was different.");
} finally {
@ -157,4 +158,4 @@ function run_test() {
} finally {
prefs.resetBranch("");
}
}
});

8
services/sync/tests/unit/test_prefs_tracker.js
Просмотреть файл

@ -8,7 +8,7 @@ Cu.import("resource://services-sync/engines/prefs.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
function run_test() {
add_task(async function run_test() {
let engine = Service.engineManager.get("prefs");
let tracker = engine._tracker;
@ -28,7 +28,7 @@ function run_test() {
do_check_true(tracker.modified);
_("Engine's getChangedID() just returns the one GUID we have.");
let changedIDs = engine.getChangedIDs();
let changedIDs = await engine.getChangedIDs();
let ids = Object.keys(changedIDs);
do_check_eq(ids.length, 1);
do_check_eq(ids[0], CommonUtils.encodeBase64URL(Services.appinfo.ID));
@ -37,7 +37,7 @@ function run_test() {
do_check_false(tracker.modified);
_("No modified state, so no changed IDs.");
do_check_empty(engine.getChangedIDs());
do_check_empty((await engine.getChangedIDs()));
_("Initial score is 0");
do_check_eq(tracker.score, 0);
@ -85,4 +85,4 @@ function run_test() {
Svc.Obs.notify("weave:engine:stop-tracking");
prefs.resetBranch("");
}
}
});

9
services/sync/tests/unit/test_resource_ua.js
Просмотреть файл

@ -45,16 +45,15 @@ add_task(async function setup() {
" FxSync/" + WEAVE_VERSION + "." +
Services.appinfo.appBuildID;
})
});
add_test(function test_fetchInfo() {
add_task(async function test_fetchInfo() {
_("Testing _fetchInfo.");
Service.login();
Service._fetchInfo();
await Service.login();
await Service._fetchInfo();
_("User-Agent: " + ua);
do_check_eq(ua, expectedUA + ".desktop");
ua = "";
run_next_test();
});
add_task(async function test_desktop_post() {

19
services/sync/tests/unit/test_score_triggers.js
Просмотреть файл

@ -38,7 +38,7 @@ function sync_httpd_setup() {
}
async function setUp(server) {
let engineInfo = registerRotaryEngine();
let engineInfo = await registerRotaryEngine();
await SyncTestingInfrastructure(server, "johndoe", "ilovejane");
return engineInfo;
}
@ -51,9 +51,9 @@ function run_test() {
run_next_test();
}
add_test(function test_tracker_score_updated() {
add_task(async function test_tracker_score_updated() {
enableValidationPrefs();
let { engine, tracker } = registerRotaryEngine();
let { engine, tracker } = await registerRotaryEngine();
let scoreUpdated = 0;
@ -75,7 +75,6 @@ add_test(function test_tracker_score_updated() {
tracker.resetScore();
tracker.clearChangedIDs();
Service.engineManager.unregister(engine);
run_next_test();
}
});
@ -83,7 +82,7 @@ add_task(async function test_sync_triggered() {
let server = sync_httpd_setup();
let { engine, tracker } = await setUp(server);
Service.login();
await Service.login();
Service.scheduler.syncThreshold = MULTI_DEVICE_THRESHOLD;
@ -93,7 +92,7 @@ add_task(async function test_sync_triggered() {
await promiseOneObserver("weave:service:sync:finish");
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
tracker.clearChangedIDs();
@ -111,7 +110,7 @@ add_task(async function test_clients_engine_sync_triggered() {
let server = sync_httpd_setup();
let { engine, tracker } = await setUp(server);
Service.login();
await Service.login();
Service.scheduler.syncThreshold = MULTI_DEVICE_THRESHOLD;
do_check_eq(Status.login, LOGIN_SUCCEEDED);
@ -120,7 +119,7 @@ add_task(async function test_clients_engine_sync_triggered() {
await promiseOneObserver("weave:service:sync:finish");
_("Sync due to clients engine change completed.");
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
tracker.clearChangedIDs();
@ -148,13 +147,13 @@ add_task(async function test_incorrect_credentials_sync_not_triggered() {
// we can account for the timer in delayedAutoconnect) and then one event
// loop tick (to account for a possible call to weave:service:sync:start).
await promiseNamedTimer(150, {}, "timer");
await promiseNextTick();
await Async.promiseYield();
Svc.Obs.remove("weave:service:sync:start", onSyncStart);
do_check_eq(Status.login, LOGIN_FAILED_LOGIN_REJECTED);
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
tracker.clearChangedIDs();

32
services/sync/tests/unit/test_service_detect_upgrade.js
Просмотреть файл

@ -11,8 +11,6 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Service.engineManager.register(TabEngine);
add_task(async function v4_upgrade() {
enableValidationPrefs();
@ -51,12 +49,12 @@ add_task(async function v4_upgrade() {
await configureIdentity({ "username": "johndoe" }, server);
Service.login();
await Service.login();
do_check_true(Service.isLoggedIn);
Service.verifyAndFetchSymmetricKeys();
do_check_true(Service._remoteSetup());
await Service.verifyAndFetchSymmetricKeys();
do_check_true((await Service._remoteSetup()));
function test_out_of_date() {
async function test_out_of_date() {
_("Old meta/global: " + JSON.stringify(meta_global));
meta_global.payload = JSON.stringify({"syncID": "foooooooooooooooooooooooooo",
"storageVersion": STORAGE_VERSION + 1});
@ -64,7 +62,7 @@ add_task(async function v4_upgrade() {
_("New meta/global: " + JSON.stringify(meta_global));
Service.recordManager.set(Service.metaURL, meta_global);
try {
Service.sync();
await Service.sync();
} catch (ex) {
}
do_check_eq(Service.status.sync, VERSION_OUT_OF_DATE);
@ -72,12 +70,12 @@ add_task(async function v4_upgrade() {
// See what happens when we bump the storage version.
_("Syncing after server has been upgraded.");
test_out_of_date();
await test_out_of_date();
// Same should happen after a wipe.
_("Syncing after server has been upgraded and wiped.");
Service.wipeServer();
test_out_of_date();
await Service.wipeServer();
await test_out_of_date();
// Now's a great time to test what happens when keys get replaced.
_("Syncing afresh...");
@ -87,9 +85,9 @@ add_task(async function v4_upgrade() {
"storageVersion": STORAGE_VERSION});
collections.meta = Date.now() / 1000;
Service.recordManager.set(Service.metaURL, meta_global);
Service.login();
await Service.login();
do_check_true(Service.isLoggedIn);
Service.sync();
await Service.sync();
do_check_true(Service.isLoggedIn);
let serverDecrypted;
@ -150,8 +148,8 @@ add_task(async function v4_upgrade() {
let oldClientsModified = collections.clients;
let oldTabsModified = collections.tabs;
Service.login();
Service.sync();
await Service.login();
await Service.sync();
_("New key should have forced upload of data.");
_("Tabs: " + oldTabsModified + " < " + collections.tabs);
_("Clients: " + oldClientsModified + " < " + collections.clients);
@ -162,7 +160,7 @@ add_task(async function v4_upgrade() {
await retrieve_and_compare_default(true);
// Clean up.
Service.startOver();
await Service.startOver();
} finally {
Svc.Prefs.resetBranch("");
@ -234,7 +232,7 @@ add_task(async function v5_upgrade() {
_("Logging in.");
try {
Service.login();
await Service.login();
} catch (e) {
_("Exception: " + e);
}
@ -243,7 +241,7 @@ add_task(async function v5_upgrade() {
do_check_eq(VERSION_OUT_OF_DATE, Service.status.sync);
// Clean up.
Service.startOver();
await Service.startOver();
} finally {
Svc.Prefs.resetBranch("");

31
services/sync/tests/unit/test_service_login.js
Просмотреть файл

@ -8,6 +8,8 @@ Cu.import("resource://services-sync/policies.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Log.repository.rootLogger.addAppender(new Log.DumpAppender());
function login_handling(handler) {
return function(request, response) {
if (has_hawk_header(request)) {
@ -21,22 +23,15 @@ function login_handling(handler) {
};
}
function run_test() {
Log.repository.rootLogger.addAppender(new Log.DumpAppender());
run_next_test();
}
add_test(function test_offline() {
add_task(async function test_offline() {
try {
_("The right bits are set when we're offline.");
Services.io.offline = true;
do_check_false(!!Service.login());
do_check_false(!!(await Service.login()));
do_check_eq(Service.status.login, LOGIN_FAILED_NETWORK_ERROR);
Services.io.offline = false;
} finally {
Svc.Prefs.resetBranch("");
run_next_test();
}
});
@ -73,25 +68,25 @@ add_task(async function test_login_logout() {
do_check_eq(Service.status.service, STATUS_OK);
_("Try logging in. It won't work because we're not configured yet.");
Service.login();
await Service.login();
do_check_eq(Service.status.service, CLIENT_NOT_CONFIGURED);
do_check_eq(Service.status.login, LOGIN_FAILED_NO_USERNAME);
do_check_false(Service.isLoggedIn);
_("Try again with a configured account");
await configureIdentity({ username: "johndoe" }, server);
Service.login();
await Service.login();
do_check_eq(Service.status.service, STATUS_OK);
do_check_eq(Service.status.login, LOGIN_SUCCEEDED);
do_check_true(Service.isLoggedIn);
_("Profile refresh edge case: FxA configured but prefs reset");
Service.startOver();
await Service.startOver();
let config = makeIdentityConfig({ username: "johndoe" }, server);
config.fxaccount.token.endpoint = server.baseURI + "/1.1/" + config.username + "/";
configureFxAccountIdentity(Service.identity, config);
Service.login();
await Service.login();
do_check_eq(Service.status.service, STATUS_OK);
do_check_eq(Service.status.login, LOGIN_SUCCEEDED);
do_check_true(Service.isLoggedIn);
@ -120,14 +115,14 @@ add_task(async function test_login_on_sync() {
_("Sync calls login.");
let oldLogin = Service.login;
let loginCalled = false;
Service.login = function() {
Service.login = async function() {
loginCalled = true;
Service.status.login = LOGIN_SUCCEEDED;
this._loggedIn = false; // So that sync aborts.
return true;
};
Service.sync();
await Service.sync();
do_check_true(loginCalled);
Service.login = oldLogin;
@ -182,10 +177,10 @@ add_task(async function test_login_on_sync() {
let lockedSyncCalled = false;
Service.scheduler.clearSyncTriggers = function() { cSTCalled = true; };
Service._lockedSync = function() { lockedSyncCalled = true; };
Service._lockedSync = async function() { lockedSyncCalled = true; };
_("If master password is canceled, login fails and we report lockage.");
do_check_false(!!Service.login());
do_check_false(!!(await Service.login()));
do_check_eq(Service.status.login, MASTER_PASSWORD_LOCKED);
do_check_eq(Service.status.service, LOGIN_FAILED);
_("Locked? " + Utils.mpLocked());
@ -193,7 +188,7 @@ add_task(async function test_login_on_sync() {
do_check_eq(Service._checkSync(), kSyncMasterPasswordLocked);
_("Sync doesn't proceed and clears triggers if MP is still locked.");
Service.sync();
await Service.sync();
do_check_true(cSTCalled);
do_check_false(lockedSyncCalled);

28
services/sync/tests/unit/test_service_startOver.js
Просмотреть файл

@ -7,6 +7,8 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging("Trace");
function BlaEngine() {
SyncEngine.call(this, "Bla", Service);
}
@ -20,13 +22,9 @@ BlaEngine.prototype = {
};
Service.engineManager.register(BlaEngine);
function run_test() {
initTestLogging("Trace");
run_next_test();
}
add_task(async function setup() {
await Service.engineManager.register(BlaEngine);
});
add_task(async function test_resetLocalData() {
await configureIdentity();
@ -46,7 +44,7 @@ add_task(async function test_resetLocalData() {
do_check_eq(Service.status.service, CLIENT_NOT_CONFIGURED);
});
Service.startOver();
await Service.startOver();
do_check_true(observerCalled);
// Verify the site was nuked from orbit.
@ -58,24 +56,22 @@ add_task(async function test_resetLocalData() {
do_check_eq(Service.status.minimumNextSync, 0);
});
add_test(function test_removeClientData() {
add_task(async function test_removeClientData() {
let engine = Service.engineManager.get("bla");
// No cluster URL = no removal.
do_check_false(engine.removed);
Service.startOver();
await Service.startOver();
do_check_false(engine.removed);
Service.clusterURL = "https://localhost/";
do_check_false(engine.removed);
Service.startOver();
await Service.startOver();
do_check_true(engine.removed);
run_next_test();
});
add_test(function test_reset_SyncScheduler() {
add_task(async function test_reset_SyncScheduler() {
// Some non-default values for SyncScheduler's attributes.
Service.scheduler.idle = true;
Service.scheduler.hasIncomingItems = true;
@ -84,7 +80,7 @@ add_test(function test_reset_SyncScheduler() {
Service.scheduler.syncThreshold = MULTI_DEVICE_THRESHOLD;
Service.scheduler.syncInterval = Service.scheduler.activeInterval;
Service.startOver();
await Service.startOver();
do_check_false(Service.scheduler.idle);
do_check_false(Service.scheduler.hasIncomingItems);
@ -92,6 +88,4 @@ add_test(function test_reset_SyncScheduler() {
do_check_eq(Service.scheduler.nextSync, 0);
do_check_eq(Service.scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
do_check_eq(Service.scheduler.syncInterval, Service.scheduler.singleDeviceInterval);
run_next_test();
});

26
services/sync/tests/unit/test_service_startup.js
Просмотреть файл

@ -28,22 +28,24 @@ function run_test() {
_("Service is enabled.");
do_check_eq(Service.enabled, true);
_("Engines are registered.");
let engines = Service.engineManager.getAll();
do_check_true(Utils.deepEquals(engines.map(engine => engine.name),
["tabs", "bookmarks", "forms", "history"]));
_("Observers are notified of startup");
do_test_pending();
do_check_false(Service.status.ready);
do_check_false(xps.ready);
Observers.add("weave:service:ready", function(subject, data) {
do_check_true(Service.status.ready);
do_check_true(xps.ready);
// Clean up.
Svc.Prefs.resetBranch("");
do_test_finished();
});
Async.promiseSpinningly(promiseOneObserver("weave:service:ready"));
do_check_true(Service.status.ready);
do_check_true(xps.ready);
_("Engines are registered.");
let engines = Service.engineManager.getAll();
do_check_true(Utils.deepEquals(engines.map(engine => engine.name),
["tabs", "bookmarks", "forms", "history"]));
// Clean up.
Svc.Prefs.resetBranch("");
do_test_finished();
}

6
services/sync/tests/unit/test_service_sync_401.js
Просмотреть файл

@ -47,7 +47,7 @@ add_task(async function run_test() {
});
_("Initial state: We're successfully logged in.");
Service.login();
await Service.login();
do_check_true(Service.isLoggedIn);
do_check_eq(Service.status.login, LOGIN_SUCCEEDED);
@ -56,7 +56,7 @@ add_task(async function run_test() {
Service.identity.unlockAndVerifyAuthState = () => Promise.resolve(LOGIN_FAILED_LOGIN_REJECTED);
_("Let's try to sync.");
Service.sync();
await Service.sync();
_("Verify that sync() threw an exception.");
do_check_true(threw);
@ -71,7 +71,7 @@ add_task(async function run_test() {
_("Our next sync will fail appropriately.");
try {
Service.sync();
await Service.sync();
} catch (ex) {
}
do_check_eq(Service.status.login, LOGIN_FAILED_LOGIN_REJECTED);

6
services/sync/tests/unit/test_service_sync_locked.js
Просмотреть файл

@ -4,7 +4,7 @@
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
function run_test() {
add_task(async function run_test() {
validate_all_future_pings();
let debug = [];
let info = [];
@ -28,10 +28,10 @@ function run_test() {
_("Check that sync will log appropriately if already in 'progress'.");
Service._locked = true;
Service.sync();
await Service.sync();
Service._locked = false;
do_check_true(debug[debug.length - 2].startsWith("Exception calling WrappedLock: Could not acquire lock. Label: \"service.js: login\"."));
do_check_eq(info[info.length - 1], "Cannot start sync: already syncing?");
}
});

36
services/sync/tests/unit/test_service_sync_remoteSetup.js
Просмотреть файл

@ -77,16 +77,16 @@ add_task(async function run_test() {
try {
_("Checking Status.sync with no credentials.");
Service.verifyAndFetchSymmetricKeys();
await Service.verifyAndFetchSymmetricKeys();
do_check_eq(Service.status.sync, CREDENTIALS_CHANGED);
do_check_eq(Service.status.login, LOGIN_FAILED_NO_PASSPHRASE);
await configureIdentity({ username: "johndoe" }, server);
Service.login();
await Service.login();
_("Checking that remoteSetup returns true when credentials have changed.");
(await Service.recordManager.get(Service.metaURL)).payload.syncID = "foobar";
do_check_true(Service._remoteSetup());
do_check_true((await Service._remoteSetup()));
let returnStatusCode = (method, code) => (oldMethod) => (req, res) => {
if (req.method === method) {
@ -99,27 +99,27 @@ add_task(async function run_test() {
let mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 401));
Service.recordManager.del(Service.metaURL);
_("Checking that remoteSetup returns false on 401 on first get /meta/global.");
do_check_false(Service._remoteSetup());
do_check_false((await Service._remoteSetup()));
mock.restore();
Service.login();
await Service.login();
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 503));
Service.recordManager.del(Service.metaURL);
_("Checking that remoteSetup returns false on 503 on first get /meta/global.");
do_check_false(Service._remoteSetup());
do_check_false((await Service._remoteSetup()));
do_check_eq(Service.status.sync, METARECORD_DOWNLOAD_FAIL);
mock.restore();
Service.login();
await Service.login();
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 404));
Service.recordManager.del(Service.metaURL);
_("Checking that remoteSetup recovers on 404 on first get /meta/global.");
do_check_true(Service._remoteSetup());
do_check_true((await Service._remoteSetup()));
mock.restore();
let makeOutdatedMeta = () => {
let makeOutdatedMeta = async () => {
Service.metaModified = 0;
let infoResponse = Service._fetchInfo();
let infoResponse = await Service._fetchInfo();
return {
status: infoResponse.status,
obj: {
@ -133,24 +133,24 @@ add_task(async function run_test() {
_("Checking that remoteSetup recovers on 404 on get /meta/global after clear cached one.");
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 404));
Service.recordManager.set(Service.metaURL, { isNew: false });
do_check_true(Service._remoteSetup(makeOutdatedMeta()));
do_check_true((await Service._remoteSetup((await makeOutdatedMeta()))));
mock.restore();
_("Checking that remoteSetup returns false on 503 on get /meta/global after clear cached one.");
mock = mockHandler(GLOBAL_PATH, returnStatusCode("GET", 503));
Service.status.sync = "";
Service.recordManager.set(Service.metaURL, { isNew: false });
do_check_false(Service._remoteSetup(makeOutdatedMeta()));
do_check_false((await Service._remoteSetup((await makeOutdatedMeta()))));
do_check_eq(Service.status.sync, "");
mock.restore();
metaColl.delete({});
_("Do an initial sync.");
Service.sync();
await Service.sync();
_("Checking that remoteSetup returns true.");
do_check_true(Service._remoteSetup());
do_check_true((await Service._remoteSetup()));
_("Verify that the meta record was uploaded.");
do_check_eq(meta_global.data.syncID, Service.syncID);
@ -161,11 +161,11 @@ add_task(async function run_test() {
_("Set the collection info hash so that sync() will remember the modified times for future runs.");
collections.meta = Service.clientsEngine.lastSync;
collections.clients = Service.clientsEngine.lastSync;
Service.sync();
await Service.sync();
_("Sync again and verify that meta/global wasn't downloaded again");
meta_global.wasCalled = false;
Service.sync();
await Service.sync();
do_check_false(meta_global.wasCalled);
_("Fake modified records. This will cause a redownload, but not reupload since it hasn't changed.");
@ -174,7 +174,7 @@ add_task(async function run_test() {
let metaModified = meta_global.modified;
Service.sync();
await Service.sync();
do_check_true(meta_global.wasCalled);
do_check_eq(metaModified, meta_global.modified);
@ -189,7 +189,7 @@ add_task(async function run_test() {
keys.encrypt(b);
keys.upload(Service.resource(Service.cryptoKeysURL));
do_check_false(Service.verifyAndFetchSymmetricKeys());
do_check_false((await Service.verifyAndFetchSymmetricKeys()));
do_check_eq(Service.status.login, LOGIN_FAILED_INVALID_PASSPHRASE);
} finally {
Svc.Prefs.resetBranch("");

39
services/sync/tests/unit/test_service_sync_specified.js
Просмотреть файл

@ -9,9 +9,6 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging();
Service.engineManager.clear();
let syncedEngines = []
function SteamEngine() {
@ -19,22 +16,20 @@ function SteamEngine() {
}
SteamEngine.prototype = {
__proto__: SyncEngine.prototype,
_sync: function _sync() {
async _sync() {
syncedEngines.push(this.name);
}
};
Service.engineManager.register(SteamEngine);
function StirlingEngine() {
SyncEngine.call(this, "Stirling", Service);
}
StirlingEngine.prototype = {
__proto__: SteamEngine.prototype,
_sync: function _sync() {
async _sync() {
syncedEngines.push(this.name);
}
};
Service.engineManager.register(StirlingEngine);
// Tracking info/collections.
var collectionsHelper = track_collections_helper();
@ -74,14 +69,18 @@ async function setUp() {
return server;
}
function run_test() {
add_task(async function setup() {
initTestLogging();
Service.engineManager.clear();
initTestLogging("Trace");
validate_all_future_pings();
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
run_next_test();
}
await Service.engineManager.register(SteamEngine);
await Service.engineManager.register(StirlingEngine);
});
add_task(async function test_noEngines() {
enableValidationPrefs();
@ -91,11 +90,11 @@ add_task(async function test_noEngines() {
try {
_("Sync with no engines specified.");
Service.sync([]);
await Service.sync([]);
deepEqual(syncedEngines, [], "no engines were synced");
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -109,11 +108,11 @@ add_task(async function test_oneEngine() {
try {
_("Sync with 1 engine specified.");
Service.sync(["steam"]);
await Service.sync(["steam"]);
deepEqual(syncedEngines, ["steam"])
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -126,11 +125,11 @@ add_task(async function test_bothEnginesSpecified() {
try {
_("Sync with both engines specified.");
Service.sync(["steam", "stirling"]);
await Service.sync(["steam", "stirling"]);
deepEqual(syncedEngines, ["steam", "stirling"])
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -143,11 +142,11 @@ add_task(async function test_bothEnginesSpecified() {
try {
_("Sync with both engines specified.");
Service.sync(["stirling", "steam"]);
await Service.sync(["stirling", "steam"]);
deepEqual(syncedEngines, ["stirling", "steam"])
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -159,11 +158,11 @@ add_task(async function test_bothEnginesDefault() {
let server = await setUp();
try {
Service.sync();
await Service.sync();
deepEqual(syncedEngines, ["steam", "stirling"])
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});

56
services/sync/tests/unit/test_service_sync_updateEnabledEngines.js
Просмотреть файл

@ -9,14 +9,11 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
initTestLogging();
Service.engineManager.clear();
function QuietStore() {
Store.call("Quiet");
}
QuietStore.prototype = {
getAllIDs: function getAllIDs() {
async getAllIDs() {
return [];
}
}
@ -29,11 +26,10 @@ SteamEngine.prototype = {
// We're not interested in engine sync but what the service does.
_storeObj: QuietStore,
_sync: function _sync() {
this._syncStartup();
_sync: async function _sync() {
await this._syncStartup();
}
};
Service.engineManager.register(SteamEngine);
function StirlingEngine() {
SyncEngine.call(this, "Stirling", Service);
@ -45,7 +41,6 @@ StirlingEngine.prototype = {
return "steam";
}
};
Service.engineManager.register(StirlingEngine);
// Tracking info/collections.
var collectionsHelper = track_collections_helper();
@ -80,15 +75,18 @@ async function setUp(server) {
const PAYLOAD = 42;
add_task(async function setup() {
initTestLogging();
Service.engineManager.clear();
function run_test() {
initTestLogging("Trace");
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
Log.repository.getLogger("Sync.ErrorHandler").level = Log.Level.Trace;
validate_all_future_pings();
run_next_test();
}
await Service.engineManager.register(SteamEngine);
await Service.engineManager.register(StirlingEngine);
});
add_task(async function test_newAccount() {
enableValidationPrefs();
@ -108,12 +106,12 @@ add_task(async function test_newAccount() {
Service._ignorePrefObserver = false;
_("Sync.");
Service.sync();
await Service.sync();
_("Engine continues to be enabled.");
do_check_true(engine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -138,7 +136,7 @@ add_task(async function test_enabledLocally() {
engine.enabled = true;
_("Sync.");
Service.sync();
await Service.sync();
_("Meta record now contains the new engine.");
do_check_true(!!metaWBO.data.engines.steam);
@ -146,7 +144,7 @@ add_task(async function test_enabledLocally() {
_("Engine continues to be enabled.");
do_check_true(engine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -179,7 +177,7 @@ add_task(async function test_disabledLocally() {
engine.enabled = false;
_("Sync.");
Service.sync();
await Service.sync();
_("Meta record no longer contains engine.");
do_check_false(!!metaWBO.data.engines.steam);
@ -190,7 +188,7 @@ add_task(async function test_disabledLocally() {
_("Engine continues to be disabled.");
do_check_false(engine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -234,7 +232,7 @@ add_task(async function test_disabledLocally_wipe503() {
await promiseObserved;
do_check_eq(Service.status.sync, SERVER_MAINTENANCE);
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
});
@ -271,7 +269,7 @@ add_task(async function test_enabledRemotely() {
do_check_false(engine.enabled);
_("Sync.");
Service.sync();
await Service.sync();
_("Engine is enabled.");
do_check_true(engine.enabled);
@ -279,7 +277,7 @@ add_task(async function test_enabledRemotely() {
_("Meta record still present.");
do_check_eq(metaWBO.data.engines.steam.syncID, engine.syncID);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -309,7 +307,7 @@ add_task(async function test_disabledRemotelyTwoClients() {
Service._ignorePrefObserver = false;
_("Sync.");
Service.sync();
await Service.sync();
_("Disable engine by deleting from meta/global.");
let d = metaWBO.data;
@ -319,13 +317,13 @@ add_task(async function test_disabledRemotelyTwoClients() {
_("Add a second client and verify that the local pref is changed.");
Service.clientsEngine._store._remoteClients["foobar"] = {name: "foobar", type: "desktop"};
Service.sync();
await Service.sync();
_("Engine is disabled.");
do_check_false(engine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -352,13 +350,13 @@ add_task(async function test_disabledRemotely() {
Service._ignorePrefObserver = false;
_("Sync.");
Service.sync();
await Service.sync();
_("Engine is not disabled: only one client.");
do_check_true(engine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -385,7 +383,7 @@ add_task(async function test_dependentEnginesEnabledLocally() {
steamEngine.enabled = true;
_("Sync.");
Service.sync();
await Service.sync();
_("Meta record now contains the new engines.");
do_check_true(!!metaWBO.data.engines.steam);
@ -395,7 +393,7 @@ add_task(async function test_dependentEnginesEnabledLocally() {
do_check_true(steamEngine.enabled);
do_check_true(stirlingEngine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});
@ -436,7 +434,7 @@ add_task(async function test_dependentEnginesDisabledLocally() {
do_check_false(stirlingEngine.enabled);
_("Sync.");
Service.sync();
await Service.sync();
_("Meta record no longer contains engines.");
do_check_false(!!metaWBO.data.engines.steam);
@ -450,7 +448,7 @@ add_task(async function test_dependentEnginesDisabledLocally() {
do_check_false(steamEngine.enabled);
do_check_false(stirlingEngine.enabled);
} finally {
Service.startOver();
await Service.startOver();
await promiseStopServer(server);
}
});

10
services/sync/tests/unit/test_service_verifyLogin.js
Просмотреть файл

@ -55,14 +55,14 @@ add_task(async function test_verifyLogin() {
_("Credentials won't check out because we're not configured yet.");
Service.status.resetSync();
do_check_false(Service.verifyLogin());
do_check_false((await Service.verifyLogin()));
do_check_eq(Service.status.service, CLIENT_NOT_CONFIGURED);
do_check_eq(Service.status.login, LOGIN_FAILED_NO_USERNAME);
_("Success if syncBundleKey is set.");
Service.status.resetSync();
await configureIdentity({ username: "johndoe" }, server);
do_check_true(Service.verifyLogin());
do_check_true((await Service.verifyLogin()));
do_check_eq(Service.status.service, STATUS_OK);
do_check_eq(Service.status.login, LOGIN_SUCCEEDED);
@ -76,7 +76,7 @@ add_task(async function test_verifyLogin() {
Svc.Obs.remove("weave:service:backoff:interval", observe);
backoffInterval = subject;
});
do_check_false(Service.verifyLogin());
do_check_false((await Service.verifyLogin()));
do_check_true(Service.status.enforceBackoff);
do_check_eq(backoffInterval, 42);
do_check_eq(Service.status.service, LOGIN_FAILED);
@ -86,14 +86,14 @@ add_task(async function test_verifyLogin() {
Service.status.resetSync();
Service.clusterURL = "";
Service._clusterManager._findCluster = () => "http://localhost:12345/";
do_check_false(Service.verifyLogin());
do_check_false((await Service.verifyLogin()));
do_check_eq(Service.status.service, LOGIN_FAILED);
do_check_eq(Service.status.login, LOGIN_FAILED_NETWORK_ERROR);
_("Ensure a network error when getting the collection info sets the right Status bits.");
Service.status.resetSync();
Service.clusterURL = "http://localhost:12345/";
do_check_false(Service.verifyLogin());
do_check_false((await Service.verifyLogin()));
do_check_eq(Service.status.service, LOGIN_FAILED);
do_check_eq(Service.status.login, LOGIN_FAILED_NETWORK_ERROR);

56
services/sync/tests/unit/test_service_wipeClient.js
Просмотреть файл

@ -8,8 +8,6 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Service.engineManager.clear();
function CanDecryptEngine() {
SyncEngine.call(this, "CanDecrypt", Service);
}
@ -17,16 +15,15 @@ CanDecryptEngine.prototype = {
__proto__: SyncEngine.prototype,
// Override these methods with mocks for the test
canDecrypt: function canDecrypt() {
async canDecrypt() {
return true;
},
wasWiped: false,
wipeClient: function wipeClient() {
async wipeClient() {
this.wasWiped = true;
}
};
Service.engineManager.register(CanDecryptEngine);
function CannotDecryptEngine() {
@ -36,50 +33,51 @@ CannotDecryptEngine.prototype = {
__proto__: SyncEngine.prototype,
// Override these methods with mocks for the test
canDecrypt: function canDecrypt() {
async canDecrypt() {
return false;
},
wasWiped: false,
wipeClient: function wipeClient() {
async wipeClient() {
this.wasWiped = true;
}
};
Service.engineManager.register(CannotDecryptEngine);
let canDecryptEngine;
let cannotDecryptEngine;
add_test(function test_withEngineList() {
add_task(async function setup() {
initTestLogging();
Service.engineManager.clear();
await Service.engineManager.register(CanDecryptEngine);
await Service.engineManager.register(CannotDecryptEngine);
canDecryptEngine = Service.engineManager.get("candecrypt");
cannotDecryptEngine = Service.engineManager.get("cannotdecrypt");
});
add_task(async function test_withEngineList() {
try {
_("Ensure initial scenario.");
do_check_false(Service.engineManager.get("candecrypt").wasWiped);
do_check_false(Service.engineManager.get("cannotdecrypt").wasWiped);
do_check_false(canDecryptEngine.wasWiped);
do_check_false(cannotDecryptEngine.wasWiped);
_("Wipe local engine data.");
Service.wipeClient(["candecrypt", "cannotdecrypt"]);
await Service.wipeClient(["candecrypt", "cannotdecrypt"]);
_("Ensure only the engine that can decrypt was wiped.");
do_check_true(Service.engineManager.get("candecrypt").wasWiped);
do_check_false(Service.engineManager.get("cannotdecrypt").wasWiped);
do_check_true(canDecryptEngine.wasWiped);
do_check_false(cannotDecryptEngine.wasWiped);
} finally {
Service.engineManager.get("candecrypt").wasWiped = false;
Service.engineManager.get("cannotdecrypt").wasWiped = false;
Service.startOver();
canDecryptEngine.wasWiped = false;
cannotDecryptEngine.wasWiped = false;
await Service.startOver();
}
run_next_test();
});
add_test(function test_startOver_clears_keys() {
add_task(async function test_startOver_clears_keys() {
generateNewKeys(Service.collectionKeys);
do_check_true(!!Service.collectionKeys.keyForCollection());
Service.startOver();
await Service.startOver();
do_check_false(!!Service.collectionKeys.keyForCollection());
run_next_test();
});
function run_test() {
initTestLogging();
run_next_test();
}

12
services/sync/tests/unit/test_service_wipeServer.js
Просмотреть файл

@ -64,7 +64,7 @@ add_task(async function test_wipeServer_list_success() {
do_check_false(diesel_coll.deleted);
_("wipeServer() will happily ignore the non-existent collection and use the timestamp of the last DELETE that was successful.");
let timestamp = Service.wipeServer(["steam", "diesel", "petrol"]);
let timestamp = await Service.wipeServer(["steam", "diesel", "petrol"]);
do_check_eq(timestamp, diesel_coll.timestamp);
_("wipeServer stopped deleting after encountering an error with the 'petrol' collection, thus only 'steam' has been deleted.");
@ -100,7 +100,7 @@ add_task(async function test_wipeServer_list_503() {
_("wipeServer() will happily ignore the non-existent collection, delete the 'steam' collection and abort after an receiving an error on the 'petrol' collection.");
let error;
try {
Service.wipeServer(["non-existent", "steam", "petrol", "diesel"]);
await Service.wipeServer(["non-existent", "steam", "petrol", "diesel"]);
do_throw("Should have thrown!");
} catch (ex) {
error = ex;
@ -140,7 +140,7 @@ add_task(async function test_wipeServer_all_success() {
_("Try deletion.");
await SyncTestingInfrastructure(server, "johndoe", "irrelevant");
let returnedTimestamp = Service.wipeServer();
let returnedTimestamp = await Service.wipeServer();
do_check_true(deleted);
do_check_eq(returnedTimestamp, serverTimestamp);
@ -172,7 +172,7 @@ add_task(async function test_wipeServer_all_404() {
_("Try deletion.");
await SyncTestingInfrastructure(server, "johndoe", "irrelevant");
let returnedTimestamp = Service.wipeServer();
let returnedTimestamp = await Service.wipeServer();
do_check_true(deleted);
do_check_eq(returnedTimestamp, serverTimestamp);
@ -201,7 +201,7 @@ add_task(async function test_wipeServer_all_503() {
let error;
try {
await SyncTestingInfrastructure(server, "johndoe", "irrelevant");
Service.wipeServer();
await Service.wipeServer();
do_throw("Should have thrown!");
} catch (ex) {
error = ex;
@ -221,7 +221,7 @@ add_task(async function test_wipeServer_all_connectionRefused() {
_("Try deletion.");
try {
Service.wipeServer();
await Service.wipeServer();
do_throw("Should have thrown!");
} catch (ex) {
do_check_eq(ex.result, Cr.NS_ERROR_CONNECTION_REFUSED);

35
services/sync/tests/unit/test_syncedtabs.js
Просмотреть файл

@ -31,6 +31,8 @@ MockTabsEngine.prototype = {
},
}
let tabsEngine;
// A clients engine that doesn't need to be a constructor.
let MockClientsEngine = {
clientSettings: null, // Set in `configureClients`.
@ -48,36 +50,37 @@ let MockClientsEngine = {
if (this.clientSettings[id]) {
return this.clientSettings[id];
}
let engine = Weave.Service.engineManager.get("tabs");
return engine.clients[id].clientName;
return tabsEngine.clients[id].clientName;
},
}
// Configure Sync with our mock tabs engine and force it to become initialized.
Weave.Service.engineManager.unregister("tabs");
Weave.Service.engineManager.register(MockTabsEngine);
Weave.Service.clientsEngine = MockClientsEngine;
// Tell the Sync XPCOM service it is initialized.
let weaveXPCService = Cc["@mozilla.org/weave/service;1"]
.getService(Ci.nsISupports)
.wrappedJSObject;
weaveXPCService.ready = true;
function configureClients(clients, clientSettings = {}) {
// Configure the instance Sync created.
let engine = Weave.Service.engineManager.get("tabs");
// each client record is expected to have an id.
for (let [guid, client] of Object.entries(clients)) {
client.id = guid;
}
engine.clients = clients;
tabsEngine.clients = clients;
// Apply clients collection overrides.
MockClientsEngine.clientSettings = clientSettings;
// Send an observer that pretends the engine just finished a sync.
Services.obs.notifyObservers(null, "weave:engine:sync:finish", "tabs");
}
add_task(async function setup() {
await Weave.Service.promiseInitialized;
// Configure Sync with our mock tabs engine and force it to become initialized.
Weave.Service.engineManager.unregister("tabs");
await Weave.Service.engineManager.register(MockTabsEngine);
Weave.Service.clientsEngine = MockClientsEngine;
tabsEngine = Weave.Service.engineManager.get("tabs");
// Tell the Sync XPCOM service it is initialized.
let weaveXPCService = Cc["@mozilla.org/weave/service;1"]
.getService(Ci.nsISupports)
.wrappedJSObject;
weaveXPCService.ready = true;
});
// The tests.
add_task(async function test_noClients() {
// no clients, can't be tabs.

37
services/sync/tests/unit/test_syncengine.js
Просмотреть файл

@ -6,18 +6,23 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
function makeSteamEngine() {
return new SyncEngine("Steam", Service);
async function makeSteamEngine() {
let engine = new SyncEngine("Steam", Service);
await engine.initialize();
return engine;
}
var server = httpd_setup({});
let server;
add_task(async function setup() {
server = httpd_setup({});
});
add_task(async function test_url_attributes() {
_("SyncEngine url attributes");
await SyncTestingInfrastructure(server);
Service.clusterURL = "https://cluster/1.1/foo/";
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
do_check_eq(engine.storageURL, "https://cluster/1.1/foo/storage/");
do_check_eq(engine.engineURL, "https://cluster/1.1/foo/storage/steam");
@ -30,7 +35,7 @@ add_task(async function test_url_attributes() {
add_task(async function test_syncID() {
_("SyncEngine.syncID corresponds to preference");
await SyncTestingInfrastructure(server);
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
// Ensure pristine environment
do_check_eq(Svc.Prefs.get("steam.syncID"), undefined);
@ -50,7 +55,7 @@ add_task(async function test_syncID() {
add_task(async function test_lastSync() {
_("SyncEngine.lastSync and SyncEngine.lastSyncLocal correspond to preferences");
await SyncTestingInfrastructure(server);
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
// Ensure pristine environment
do_check_eq(Svc.Prefs.get("steam.lastSync"), undefined);
@ -81,7 +86,7 @@ add_task(async function test_toFetch() {
_("SyncEngine.toFetch corresponds to file on disk");
let syncTesting = await SyncTestingInfrastructure(server);
const filename = "weave/toFetch/steam.json";
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
// Ensure pristine environment
do_check_eq(engine.toFetch.length, 0);
@ -91,14 +96,14 @@ add_task(async function test_toFetch() {
engine.toFetch = toFetch;
do_check_eq(engine.toFetch, toFetch);
// toFetch is written asynchronously
engine._store._sleep(0);
await Async.promiseYield();
let fakefile = syncTesting.fakeFilesystem.fakeContents[filename];
do_check_eq(fakefile, JSON.stringify(toFetch));
// Read file from disk
toFetch = [Utils.makeGUID(), Utils.makeGUID()];
syncTesting.fakeFilesystem.fakeContents[filename] = JSON.stringify(toFetch);
engine.loadToFetch();
await engine.loadToFetch();
do_check_eq(engine.toFetch.length, 2);
do_check_eq(engine.toFetch[0], toFetch[0]);
do_check_eq(engine.toFetch[1], toFetch[1]);
@ -111,7 +116,7 @@ add_task(async function test_previousFailed() {
_("SyncEngine.previousFailed corresponds to file on disk");
let syncTesting = await SyncTestingInfrastructure(server);
const filename = "weave/failed/steam.json";
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
// Ensure pristine environment
do_check_eq(engine.previousFailed.length, 0);
@ -121,14 +126,14 @@ add_task(async function test_previousFailed() {
engine.previousFailed = previousFailed;
do_check_eq(engine.previousFailed, previousFailed);
// previousFailed is written asynchronously
engine._store._sleep(0);
await Async.promiseYield();
let fakefile = syncTesting.fakeFilesystem.fakeContents[filename];
do_check_eq(fakefile, JSON.stringify(previousFailed));
// Read file from disk
previousFailed = [Utils.makeGUID(), Utils.makeGUID()];
syncTesting.fakeFilesystem.fakeContents[filename] = JSON.stringify(previousFailed);
engine.loadPreviousFailed();
await engine.loadPreviousFailed();
do_check_eq(engine.previousFailed.length, 2);
do_check_eq(engine.previousFailed[0], previousFailed[0]);
do_check_eq(engine.previousFailed[1], previousFailed[1]);
@ -140,7 +145,7 @@ add_task(async function test_previousFailed() {
add_task(async function test_resetClient() {
_("SyncEngine.resetClient resets lastSync and toFetch");
await SyncTestingInfrastructure(server);
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
try {
// Ensure pristine environment
do_check_eq(Svc.Prefs.get("steam.lastSync"), undefined);
@ -152,7 +157,7 @@ add_task(async function test_resetClient() {
engine.toFetch = [Utils.makeGUID(), Utils.makeGUID(), Utils.makeGUID()];
engine.previousFailed = [Utils.makeGUID(), Utils.makeGUID(), Utils.makeGUID()];
engine.resetClient();
await engine.resetClient();
do_check_eq(engine.lastSync, 0);
do_check_eq(engine.lastSyncLocal, 0);
do_check_eq(engine.toFetch.length, 0);
@ -164,7 +169,7 @@ add_task(async function test_resetClient() {
add_task(async function test_wipeServer() {
_("SyncEngine.wipeServer deletes server data and resets the client.");
let engine = makeSteamEngine();
let engine = await makeSteamEngine();
const PAYLOAD = 42;
let steamCollection = new ServerWBO("steam", PAYLOAD);
@ -180,7 +185,7 @@ add_task(async function test_wipeServer() {
engine.toFetch = [Utils.makeGUID(), Utils.makeGUID(), Utils.makeGUID()];
_("Wipe server data and reset client.");
engine.wipeServer();
await engine.wipeServer();
do_check_eq(steamCollection.payload, undefined);
do_check_eq(engine.lastSync, 0);
do_check_eq(engine.toFetch.length, 0);

154
services/sync/tests/unit/test_syncengine_sync.js
Просмотреть файл

@ -110,7 +110,7 @@ add_task(async function test_syncStartup_emptyOrOutdatedGlobalsResetsSync() {
// Trying to prompt a wipe -- we no longer track CryptoMeta per engine,
// so it has nothing to check.
engine._syncStartup();
await engine._syncStartup();
// The meta/global WBO has been filled with data about the engine
let engineData = metaGlobal.payload.engines["rotary"];
@ -144,7 +144,7 @@ add_task(async function test_syncStartup_serverHasNewerVersion() {
// handle. That should give us an exception.
let error;
try {
engine._syncStartup();
await engine._syncStartup();
} catch (ex) {
error = ex;
}
@ -178,7 +178,7 @@ add_task(async function test_syncStartup_syncIDMismatchResetsClient() {
engine.lastSync = Date.now() / 1000;
engine.lastSyncLocal = Date.now();
engine._syncStartup();
await engine._syncStartup();
// The engine has assumed the server's syncID
do_check_eq(engine.syncID, "foobar");
@ -206,7 +206,7 @@ add_task(async function test_processIncoming_emptyServer() {
try {
// Merely ensure that this code path is run without any errors
engine._processIncoming();
await engine._processIncoming();
do_check_eq(engine.lastSync, 0);
} finally {
@ -257,8 +257,8 @@ add_task(async function test_processIncoming_createFromServer() {
do_check_eq(engine._store.items.scotsman, undefined);
do_check_eq(engine._store.items["../pathological"], undefined);
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Timestamps of last sync and last server modification are set.
do_check_true(engine.lastSync > 0);
@ -351,8 +351,8 @@ add_task(async function test_processIncoming_reconcile() {
do_check_eq(engine._store.items.nukeme, "Nuke me!");
do_check_true(engine._tracker.changedIDs["olderidentical"] > 0);
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Timestamps of last sync and last server modification are set.
do_check_true(engine.lastSync > 0);
@ -403,11 +403,11 @@ add_task(async function test_processIncoming_reconcile_local_deleted() {
wbo = new ServerWBO("DUPE_LOCAL", record, now - 1);
server.insertWBO(user, "rotary", wbo);
engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
do_check_true(engine._store.itemExists("DUPE_LOCAL"));
do_check_eq("DUPE_LOCAL", engine._findDupe({id: "DUPE_INCOMING"}));
await engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
do_check_true((await engine._store.itemExists("DUPE_LOCAL")));
do_check_eq("DUPE_LOCAL", (await engine._findDupe({id: "DUPE_INCOMING"})));
engine._sync();
await engine._sync();
do_check_attribute_count(engine._store.items, 1);
do_check_true("DUPE_INCOMING" in engine._store.items);
@ -433,9 +433,9 @@ add_task(async function test_processIncoming_reconcile_equivalent() {
server.insertWBO(user, "rotary", wbo);
engine._store.items = {entry: "denomination"};
do_check_true(engine._store.itemExists("entry"));
do_check_true((await engine._store.itemExists("entry")));
engine._sync();
await engine._sync();
do_check_attribute_count(engine._store.items, 1);
@ -462,11 +462,11 @@ add_task(async function test_processIncoming_reconcile_locally_deleted_dupe_new(
// Simulate a locally-deleted item.
engine._store.items = {};
engine._tracker.addChangedID("DUPE_LOCAL", now + 3);
do_check_false(engine._store.itemExists("DUPE_LOCAL"));
do_check_false(engine._store.itemExists("DUPE_INCOMING"));
do_check_eq("DUPE_LOCAL", engine._findDupe({id: "DUPE_INCOMING"}));
do_check_false((await engine._store.itemExists("DUPE_LOCAL")));
do_check_false((await engine._store.itemExists("DUPE_INCOMING")));
do_check_eq("DUPE_LOCAL", (await engine._findDupe({id: "DUPE_INCOMING"})));
engine._sync();
await engine._sync();
// After the sync, the server's payload for the original ID should be marked
// as deleted.
@ -500,11 +500,11 @@ add_task(async function test_processIncoming_reconcile_locally_deleted_dupe_old(
// Simulate a locally-deleted item.
engine._store.items = {};
engine._tracker.addChangedID("DUPE_LOCAL", now + 1);
do_check_false(engine._store.itemExists("DUPE_LOCAL"));
do_check_false(engine._store.itemExists("DUPE_INCOMING"));
do_check_eq("DUPE_LOCAL", engine._findDupe({id: "DUPE_INCOMING"}));
do_check_false((await engine._store.itemExists("DUPE_LOCAL")));
do_check_false((await engine._store.itemExists("DUPE_INCOMING")));
do_check_eq("DUPE_LOCAL", (await engine._findDupe({id: "DUPE_INCOMING"})));
engine._sync();
await engine._sync();
// Since the remote change is newer, the incoming item should exist locally.
do_check_attribute_count(engine._store.items, 1);
@ -534,12 +534,12 @@ add_task(async function test_processIncoming_reconcile_changed_dupe() {
let wbo = new ServerWBO("DUPE_INCOMING", record, now + 2);
server.insertWBO(user, "rotary", wbo);
engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
await engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
engine._tracker.addChangedID("DUPE_LOCAL", now + 3);
do_check_true(engine._store.itemExists("DUPE_LOCAL"));
do_check_eq("DUPE_LOCAL", engine._findDupe({id: "DUPE_INCOMING"}));
do_check_true((await engine._store.itemExists("DUPE_LOCAL")));
do_check_eq("DUPE_LOCAL", (await engine._findDupe({id: "DUPE_INCOMING"})));
engine._sync();
await engine._sync();
// The ID should have been changed to incoming.
do_check_attribute_count(engine._store.items, 1);
@ -572,12 +572,12 @@ add_task(async function test_processIncoming_reconcile_changed_dupe_new() {
let wbo = new ServerWBO("DUPE_INCOMING", record, now + 2);
server.insertWBO(user, "rotary", wbo);
engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
await engine._store.create({id: "DUPE_LOCAL", denomination: "local"});
engine._tracker.addChangedID("DUPE_LOCAL", now + 1);
do_check_true(engine._store.itemExists("DUPE_LOCAL"));
do_check_eq("DUPE_LOCAL", engine._findDupe({id: "DUPE_INCOMING"}));
do_check_true((await engine._store.itemExists("DUPE_LOCAL")));
do_check_eq("DUPE_LOCAL", (await engine._findDupe({id: "DUPE_INCOMING"})));
engine._sync();
await engine._sync();
// The ID should have been changed to incoming.
do_check_attribute_count(engine._store.items, 1);
@ -594,7 +594,6 @@ add_task(async function test_processIncoming_reconcile_changed_dupe_new() {
await cleanAndGo(engine, server);
});
add_task(async function test_processIncoming_resume_toFetch() {
_("toFetch and previousFailed items left over from previous syncs are fetched on the next sync, along with new items.");
@ -646,8 +645,8 @@ add_task(async function test_processIncoming_resume_toFetch() {
do_check_eq(engine._store.items.scotsman, undefined);
do_check_eq(engine._store.items.rekolok, undefined);
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Local records have been created from the server data.
do_check_eq(engine._store.items.flying, "LNER Class A3 4472");
@ -671,10 +670,10 @@ add_task(async function test_processIncoming_applyIncomingBatchSize_smaller() {
let engine = makeRotaryEngine();
engine.applyIncomingBatchSize = APPLY_BATCH_SIZE;
engine._store._applyIncomingBatch = engine._store.applyIncomingBatch;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
let failed1 = records.shift();
let failed2 = records.pop();
this._applyIncomingBatch(records);
await this._applyIncomingBatch(records);
return [failed1.id, failed2.id];
};
@ -701,8 +700,8 @@ add_task(async function test_processIncoming_applyIncomingBatchSize_smaller() {
// Confirm initial environment
do_check_empty(engine._store.items);
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Records have been applied and the expected failures have failed.
do_check_attribute_count(engine._store.items, APPLY_BATCH_SIZE - 1 - 2);
@ -727,10 +726,10 @@ add_task(async function test_processIncoming_applyIncomingBatchSize_multiple() {
engine.applyIncomingBatchSize = APPLY_BATCH_SIZE;
let batchCalls = 0;
engine._store._applyIncomingBatch = engine._store.applyIncomingBatch;
engine._store.applyIncomingBatch = function(records) {
engine._store.applyIncomingBatch = async function(records) {
batchCalls += 1;
do_check_eq(records.length, APPLY_BATCH_SIZE);
this._applyIncomingBatch.apply(this, arguments);
await this._applyIncomingBatch.apply(this, arguments);
};
// Let's create three batches worth of server side records.
@ -756,8 +755,8 @@ add_task(async function test_processIncoming_applyIncomingBatchSize_multiple() {
// Confirm initial environment
do_check_empty(engine._store.items);
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Records have been applied in 3 batches.
do_check_eq(batchCalls, 3);
@ -779,8 +778,8 @@ add_task(async function test_processIncoming_notify_count() {
let engine = makeRotaryEngine();
engine.applyIncomingBatchSize = APPLY_BATCH_SIZE;
engine._store._applyIncomingBatch = engine._store.applyIncomingBatch;
engine._store.applyIncomingBatch = function(records) {
engine._store._applyIncomingBatch(records.slice(1));
engine._store.applyIncomingBatch = async function(records) {
await engine._store._applyIncomingBatch(records.slice(1));
return [records[0].id];
};
@ -819,8 +818,8 @@ add_task(async function test_processIncoming_notify_count() {
Svc.Obs.add("weave:engine:sync:applied", onApplied);
// Do sync.
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Confirm failures.
do_check_attribute_count(engine._store.items, 12);
@ -837,7 +836,7 @@ add_task(async function test_processIncoming_notify_count() {
do_check_eq(counts.succeeded, 12);
// Sync again, 1 of the failed items are the same, the rest didn't fail.
engine._processIncoming();
await engine._processIncoming();
// Confirming removed failures.
do_check_attribute_count(engine._store.items, 14);
@ -868,8 +867,8 @@ add_task(async function test_processIncoming_previousFailed() {
let engine = makeRotaryEngine();
engine.mobileGUIDFetchBatchSize = engine.applyIncomingBatchSize = APPLY_BATCH_SIZE;
engine._store._applyIncomingBatch = engine._store.applyIncomingBatch;
engine._store.applyIncomingBatch = function(records) {
engine._store._applyIncomingBatch(records.slice(2));
engine._store.applyIncomingBatch = async function(records) {
await engine._store._applyIncomingBatch(records.slice(2));
return [records[0].id, records[1].id];
};
@ -904,8 +903,8 @@ add_task(async function test_processIncoming_previousFailed() {
do_check_eq(engine.previousFailed, previousFailed);
// Do sync.
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Expected result: 4 sync batches with 2 failures each => 8 failures
do_check_attribute_count(engine._store.items, 6);
@ -920,7 +919,7 @@ add_task(async function test_processIncoming_previousFailed() {
do_check_eq(engine.previousFailed[7], "record-no-13");
// Sync again with the same failed items (records 0, 1, 8, 9).
engine._processIncoming();
await engine._processIncoming();
// A second sync with the same failed items should not add the same items again.
// Items that did not fail a second time should no longer be in previousFailed.
@ -972,14 +971,14 @@ add_task(async function test_processIncoming_failed_records() {
engine.applyIncomingBatchSize = APPLY_BATCH_SIZE;
engine.__reconcile = engine._reconcile;
engine._reconcile = function _reconcile(record) {
engine._reconcile = async function _reconcile(record) {
if (BOGUS_RECORDS.indexOf(record.id) % 2 == 0) {
throw "I don't like this record! Baaaaaah!";
}
return this.__reconcile.apply(this, arguments);
};
engine._store._applyIncoming = engine._store.applyIncoming;
engine._store.applyIncoming = function(record) {
engine._store.applyIncoming = async function(record) {
if (BOGUS_RECORDS.indexOf(record.id) % 2 == 1) {
throw "I don't like this record! Baaaaaah!";
}
@ -1024,8 +1023,8 @@ add_task(async function test_processIncoming_failed_records() {
observerData = data;
});
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
// Ensure that all records but the bogus 4 have been applied.
do_check_attribute_count(engine._store.items,
@ -1047,23 +1046,22 @@ add_task(async function test_processIncoming_failed_records() {
// Testing batching of failed item fetches.
// Try to sync again. Ensure that we split the request into chunks to avoid
// URI length limitations.
function batchDownload(batchSize) {
async function batchDownload(batchSize) {
count = 0;
uris = [];
engine.guidFetchBatchSize = batchSize;
engine._processIncoming();
await engine._processIncoming();
_("Tried again. Requests: " + count + "; URIs: " + JSON.stringify(uris));
return count;
}
// There are 8 bad records, so this needs 3 fetches.
_("Test batching with ID batch size 3, normal mobile batch size.");
do_check_eq(batchDownload(3), 3);
do_check_eq((await batchDownload(3)), 3);
// Now see with a more realistic limit.
_("Test batching with sufficient ID batch size.");
do_check_eq(batchDownload(BOGUS_RECORDS.length), 1);
do_check_eq((await batchDownload(BOGUS_RECORDS.length)), 1);
} finally {
await cleanAndGo(engine, server);
}
@ -1184,8 +1182,8 @@ add_task(async function test_uploadOutgoing_toEmptyServer() {
do_check_eq(collection.payload("flying"), undefined);
do_check_eq(collection.payload("scotsman"), undefined);
engine._syncStartup();
engine._uploadOutgoing();
await engine._syncStartup();
await engine._uploadOutgoing();
// Local timestamp has been set.
do_check_true(engine.lastSyncLocal > 0);
@ -1240,14 +1238,14 @@ async function test_uploadOutgoing_max_record_payload_bytes(allowSkippedRecord)
do_check_eq(collection.payload("flying"), undefined);
do_check_eq(collection.payload("scotsman"), undefined);
engine._syncStartup();
engine._uploadOutgoing();
await engine._syncStartup();
await engine._uploadOutgoing();
if (!allowSkippedRecord) {
do_throw("should not get here");
}
engine.trackRemainingChanges();
await engine.trackRemainingChanges();
// Check we uploaded the other record to the server
do_check_true(collection.payload("scotsman"));
@ -1259,7 +1257,7 @@ async function test_uploadOutgoing_max_record_payload_bytes(allowSkippedRecord)
do_throw("should not get here");
}
engine.trackRemainingChanges();
await engine.trackRemainingChanges();
// Check that we will try to upload the huge record next time
do_check_eq(engine._tracker.changedIDs["flying"], 1000);
@ -1393,8 +1391,8 @@ add_task(async function test_uploadOutgoing_MAX_UPLOAD_RECORDS() {
// Confirm initial environment.
do_check_eq(noOfUploads, 0);
engine._syncStartup();
engine._uploadOutgoing();
await engine._syncStartup();
await engine._uploadOutgoing();
// Ensure all records have been uploaded.
for (i = 0; i < 234; i++) {
@ -1424,7 +1422,7 @@ async function createRecordFailTelemetry(allowSkippedRecord) {
let engine = makeRotaryEngine();
engine.allowSkippedRecord = allowSkippedRecord;
let oldCreateRecord = engine._store.createRecord;
engine._store.createRecord = (id, col) => {
engine._store.createRecord = async (id, col) => {
if (id != "flying") {
throw new Error("oops");
}
@ -1523,10 +1521,10 @@ add_task(async function test_uploadOutgoing_largeRecords() {
await SyncTestingInfrastructure(server);
try {
engine._syncStartup();
await engine._syncStartup();
let error = null;
try {
engine._uploadOutgoing();
await engine._uploadOutgoing();
} catch (e) {
error = e;
}
@ -1548,7 +1546,7 @@ add_task(async function test_syncFinish_noDelete() {
engine._tracker.score = 100;
// _syncFinish() will reset the engine's score.
engine._syncFinish();
await engine._syncFinish();
do_check_eq(engine.score, 0);
server.stop(run_next_test);
});
@ -1576,7 +1574,7 @@ add_task(async function test_syncFinish_deleteByIds() {
let engine = makeRotaryEngine();
try {
engine._delete = {ids: ["flying", "rekolok"]};
engine._syncFinish();
await engine._syncFinish();
// The 'flying' and 'rekolok' records were deleted while the
// 'scotsman' one wasn't.
@ -1638,7 +1636,7 @@ add_task(async function test_syncFinish_deleteLotsInBatches() {
engine._delete.ids.push("record-no-" + i);
}
engine._syncFinish();
await engine._syncFinish();
// Ensure that the appropriate server data has been wiped while
// preserving records 90 thru 200.
@ -1755,7 +1753,7 @@ add_task(async function test_canDecrypt_noCryptoKeys() {
let engine = makeRotaryEngine();
try {
do_check_false(engine.canDecrypt());
do_check_false((await engine.canDecrypt()));
} finally {
await cleanAndGo(engine, server);
@ -1780,7 +1778,7 @@ add_task(async function test_canDecrypt_true() {
let engine = makeRotaryEngine();
try {
do_check_true(engine.canDecrypt());
do_check_true((await engine.canDecrypt()));
} finally {
await cleanAndGo(engine, server);
@ -1827,8 +1825,8 @@ add_task(async function test_syncapplied_observer() {
Service.scheduler.hasIncomingItems = false;
// Do sync.
engine._syncStartup();
engine._processIncoming();
await engine._syncStartup();
await engine._processIncoming();
do_check_attribute_count(engine._store.items, 10);

86
services/sync/tests/unit/test_syncscheduler.js
Просмотреть файл

@ -12,28 +12,19 @@ Cu.import("resource://services-sync/status.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
Service.engineManager.clear();
function CatapultEngine() {
SyncEngine.call(this, "Catapult", Service);
}
CatapultEngine.prototype = {
__proto__: SyncEngine.prototype,
exception: null, // tests fill this in
_sync: function _sync() {
async _sync() {
throw this.exception;
}
};
Service.engineManager.register(CatapultEngine);
var scheduler = new SyncScheduler(Service);
var clientsEngine = Service.clientsEngine;
// Don't remove stale clients when syncing. This is a test-only workaround
// that lets us add clients directly to the store, without losing them on
// the next sync.
clientsEngine._removeRemoteClient = id => {};
let clientsEngine;
function sync_httpd_setup() {
let global = new ServerWBO("global", {
@ -68,15 +59,22 @@ async function setUp(server) {
}
async function cleanUpAndGo(server) {
await promiseNextTick();
clientsEngine._store.wipe();
Service.startOver();
await Async.promiseYield();
await clientsEngine._store.wipe();
await Service.startOver();
if (server) {
await promiseStopServer(server);
}
}
function run_test() {
add_task(async function setup() {
await Service.promiseInitialized;
clientsEngine = Service.clientsEngine;
// Don't remove stale clients when syncing. This is a test-only workaround
// that lets us add clients directly to the store, without losing them on
// the next sync.
clientsEngine._removeRemoteClient = async (id) => {};
Service.engineManager.clear();
initTestLogging("Trace");
Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
@ -85,8 +83,8 @@ function run_test() {
scheduler.setDefaults();
run_next_test();
}
await Service.engineManager.register(CatapultEngine);
});
add_test(function test_prefAttributes() {
_("Test various attributes corresponding to preferences.");
@ -178,7 +176,7 @@ add_task(async function test_updateClientMode() {
do_check_false(scheduler.idle);
// Resets the number of clients to 0.
clientsEngine.resetClient();
await clientsEngine.resetClient();
Svc.Prefs.reset("clients.devices.mobile");
scheduler.updateClientMode();
@ -211,7 +209,7 @@ add_task(async function test_masterpassword_locked_retry_interval() {
};
let oldVerifyLogin = Service.verifyLogin;
Service.verifyLogin = function() {
Service.verifyLogin = async function() {
Status.login = MASTER_PASSWORD_LOCKED;
return false;
};
@ -219,7 +217,7 @@ add_task(async function test_masterpassword_locked_retry_interval() {
let server = sync_httpd_setup();
await setUp(server);
Service.sync();
await Service.sync();
do_check_true(loginFailed);
do_check_eq(Status.login, MASTER_PASSWORD_LOCKED);
@ -388,7 +386,7 @@ add_task(async function test_handleSyncError() {
// Trigger sync with an error several times & observe
// functionality of handleSyncError()
_("Test first error calls scheduleNextSync on default interval");
Service.sync();
await Service.sync();
do_check_true(scheduler.nextSync <= Date.now() + scheduler.singleDeviceInterval);
do_check_eq(scheduler.syncTimer.delay, scheduler.singleDeviceInterval);
do_check_eq(scheduler._syncErrors, 1);
@ -396,7 +394,7 @@ add_task(async function test_handleSyncError() {
scheduler.syncTimer.clear();
_("Test second error still calls scheduleNextSync on default interval");
Service.sync();
await Service.sync();
do_check_true(scheduler.nextSync <= Date.now() + scheduler.singleDeviceInterval);
do_check_eq(scheduler.syncTimer.delay, scheduler.singleDeviceInterval);
do_check_eq(scheduler._syncErrors, 2);
@ -404,7 +402,7 @@ add_task(async function test_handleSyncError() {
scheduler.syncTimer.clear();
_("Test third error sets Status.enforceBackoff and calls scheduleAtInterval");
Service.sync();
await Service.sync();
let maxInterval = scheduler._syncErrors * (2 * MINIMUM_BACKOFF_INTERVAL);
do_check_eq(Status.backoffInterval, 0);
do_check_true(scheduler.nextSync <= (Date.now() + maxInterval));
@ -419,7 +417,7 @@ add_task(async function test_handleSyncError() {
scheduler.syncTimer.clear();
_("Test fourth error still calls scheduleAtInterval even if enforceBackoff was reset");
Service.sync();
await Service.sync();
maxInterval = scheduler._syncErrors * (2 * MINIMUM_BACKOFF_INTERVAL);
do_check_true(scheduler.nextSync <= Date.now() + maxInterval);
do_check_true(scheduler.syncTimer.delay <= maxInterval);
@ -447,12 +445,12 @@ add_task(async function test_client_sync_finish_updateClientMode() {
do_check_false(scheduler.idle);
// Trigger a change in interval & threshold by adding a client.
clientsEngine._store.create(
await clientsEngine._store.create(
{ id: "foo", cleartext: { os: "mobile", version: "0.01", type: "desktop" } }
);
do_check_false(scheduler.numClients > 1);
scheduler.updateClientMode();
Service.sync();
await Service.sync();
do_check_eq(scheduler.syncThreshold, MULTI_DEVICE_THRESHOLD);
do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
@ -460,11 +458,11 @@ add_task(async function test_client_sync_finish_updateClientMode() {
do_check_false(scheduler.idle);
// Resets the number of clients to 0.
clientsEngine.resetClient();
await clientsEngine.resetClient();
// Also re-init the server, or we suck our "foo" client back down.
await setUp(server);
Service.sync();
await Service.sync();
// Goes back to single user if # clients is 1.
do_check_eq(scheduler.numClients, 1);
@ -540,7 +538,7 @@ add_task(async function test_autoconnect_mp_locked() {
scheduler.delayedAutoConnect(0);
await promiseObserved;
await promiseNextTick();
await Async.promiseYield();
do_check_eq(Status.login, MASTER_PASSWORD_LOCKED);
@ -719,7 +717,7 @@ add_task(async function test_no_sync_node() {
Service._clusterManager._findCluster = () => null;
Service.clusterURL = "";
try {
Service.sync();
await Service.sync();
do_check_eq(Status.sync, NO_SYNC_NODE_FOUND);
do_check_eq(scheduler.syncTimer.delay, NO_SYNC_NODE_INTERVAL);
@ -744,7 +742,7 @@ add_task(async function test_sync_failed_partial_500s() {
do_check_true(await setUp(server));
Service.sync();
await Service.sync();
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
@ -770,7 +768,7 @@ add_task(async function test_sync_failed_partial_400s() {
engine.exception = {status: 400};
// Have multiple devices for an active interval.
clientsEngine._store.create(
await clientsEngine._store.create(
{ id: "foo", cleartext: { os: "mobile", version: "0.01", type: "desktop" } }
);
@ -778,7 +776,7 @@ add_task(async function test_sync_failed_partial_400s() {
do_check_true(await setUp(server));
Service.sync();
await Service.sync();
do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
@ -816,16 +814,16 @@ add_task(async function test_sync_X_Weave_Backoff() {
// Pretend we have two clients so that the regular sync interval is
// sufficiently low.
clientsEngine._store.create(
await clientsEngine._store.create(
{ id: "foo", cleartext: { os: "mobile", version: "0.01", type: "desktop" } }
);
let rec = clientsEngine._store.createRecord("foo", "clients");
let rec = await clientsEngine._store.createRecord("foo", "clients");
rec.encrypt(Service.collectionKeys.keyForCollection("clients"));
rec.upload(Service.resource(clientsEngine.engineURL + rec.id));
// Sync once to log in and get everything set up. Let's verify our initial
// values.
Service.sync();
await Service.sync();
do_check_eq(Status.backoffInterval, 0);
do_check_eq(Status.minimumNextSync, 0);
do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
@ -836,7 +834,7 @@ add_task(async function test_sync_X_Weave_Backoff() {
// Turn on server maintenance and sync again.
serverBackoff = true;
Service.sync();
await Service.sync();
do_check_true(Status.backoffInterval >= BACKOFF * 1000);
// Allowing 20 seconds worth of of leeway between when Status.minimumNextSync
@ -877,16 +875,16 @@ add_task(async function test_sync_503_Retry_After() {
// Pretend we have two clients so that the regular sync interval is
// sufficiently low.
clientsEngine._store.create(
await clientsEngine._store.create(
{ id: "foo", cleartext: { os: "mobile", version: "0.01", type: "desktop" } }
);
let rec = clientsEngine._store.createRecord("foo", "clients");
let rec = await clientsEngine._store.createRecord("foo", "clients");
rec.encrypt(Service.collectionKeys.keyForCollection("clients"));
rec.upload(Service.resource(clientsEngine.engineURL + rec.id));
// Sync once to log in and get everything set up. Let's verify our initial
// values.
Service.sync();
await Service.sync();
do_check_false(Status.enforceBackoff);
do_check_eq(Status.backoffInterval, 0);
do_check_eq(Status.minimumNextSync, 0);
@ -898,7 +896,7 @@ add_task(async function test_sync_503_Retry_After() {
// Turn on server maintenance and sync again.
serverMaintenance = true;
Service.sync();
await Service.sync();
do_check_true(Status.enforceBackoff);
do_check_true(Status.backoffInterval >= BACKOFF * 1000);
@ -939,7 +937,7 @@ add_task(async function test_loginError_recoverable_reschedules() {
scheduler.scheduleNextSync(0);
await promiseObserved;
await promiseNextTick();
await Async.promiseYield();
do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
@ -974,7 +972,7 @@ add_task(async function test_loginError_fatal_clearsTriggers() {
scheduler.scheduleNextSync(0);
await promiseObserved;
await promiseNextTick();
await Async.promiseYield();
// For the FxA identity, a 401 on info/collections means a transient
// error, probably due to an inability to fetch a token.
@ -1003,7 +1001,7 @@ add_task(async function test_proper_interval_on_only_failing() {
reconciled: 0
});
await promiseNextTick();
await Async.promiseYield();
scheduler.adjustSyncInterval();
do_check_false(scheduler.hasIncomingItems);
do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);

43
services/sync/tests/unit/test_tab_engine.js
Просмотреть файл

@ -8,21 +8,18 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/sync/utils.js");
function getMocks() {
async function getMocks() {
let engine = new TabEngine(Service);
await engine.initialize();
let store = engine._store;
store.getTabState = mockGetTabState;
store.shouldSkipWindow = mockShouldSkipWindow;
return [engine, store];
}
function run_test() {
run_next_test();
}
add_test(function test_getOpenURLs() {
add_task(async function test_getOpenURLs() {
_("Test getOpenURLs.");
let [engine, store] = getMocks();
let [engine, store] = await getMocks();
let superLongURL = "http://" + (new Array(MAX_UPLOAD_BYTES).join("w")) + ".com/";
let urls = ["http://bar.com", "http://foo.com", "http://foobar.com", superLongURL];
@ -45,18 +42,16 @@ add_test(function test_getOpenURLs() {
_(" test matching works (too long)");
matches = openurlsset.has(superLongURL);
ok(!matches);
run_next_test();
});
add_task(async function test_tab_engine_skips_incoming_local_record() {
_("Ensure incoming records that match local client ID are never applied.");
let [engine, store] = getMocks();
let [engine, store] = await getMocks();
let localID = engine.service.clientsEngine.localID;
let apply = store.applyIncoming;
let applied = [];
store.applyIncoming = function(record) {
store.applyIncoming = async function(record) {
notEqual(record.id, localID, "Only apply tab records from remote clients");
applied.push(record);
apply.call(store, record);
@ -89,40 +84,40 @@ add_task(async function test_tab_engine_skips_incoming_local_record() {
let promiseFinished = new Promise(resolve => {
let syncFinish = engine._syncFinish;
engine._syncFinish = function() {
engine._syncFinish = async function() {
equal(applied.length, 1, "Remote client record was applied");
equal(applied[0].id, remoteID, "Remote client ID matches");
syncFinish.call(engine);
await syncFinish.call(engine);
resolve();
}
});
_("Start sync");
engine._sync();
await engine._sync();
await promiseFinished;
});
add_test(function test_reconcile() {
let [engine, ] = getMocks();
add_task(async function test_reconcile() {
let [engine, ] = await getMocks();
_("Setup engine for reconciling");
engine._syncStartup();
await engine._syncStartup();
_("Create an incoming remote record");
let remoteRecord = {id: "remote id",
cleartext: "stuff and things!",
modified: 1000};
ok(engine._reconcile(remoteRecord), "Apply a recently modified remote record");
ok((await engine._reconcile(remoteRecord)), "Apply a recently modified remote record");
remoteRecord.modified = 0;
ok(engine._reconcile(remoteRecord), "Apply a remote record modified long ago");
ok((await engine._reconcile(remoteRecord)), "Apply a remote record modified long ago");
// Remote tab records are never tracked locally, so the only
// time they're skipped is when they're marked as deleted.
remoteRecord.deleted = true;
ok(!engine._reconcile(remoteRecord), "Skip a deleted remote record");
ok(!(await engine._reconcile(remoteRecord)), "Skip a deleted remote record");
_("Create an incoming local record");
// The locally tracked tab record always takes precedence over its
@ -131,13 +126,11 @@ add_test(function test_reconcile() {
cleartext: "this should always be skipped",
modified: 2000};
ok(!engine._reconcile(localRecord), "Skip incoming local if recently modified");
ok(!(await engine._reconcile(localRecord)), "Skip incoming local if recently modified");
localRecord.modified = 0;
ok(!engine._reconcile(localRecord), "Skip incoming local if modified long ago");
ok(!(await engine._reconcile(localRecord)), "Skip incoming local if modified long ago");
localRecord.deleted = true;
ok(!engine._reconcile(localRecord), "Skip incoming local if deleted");
run_next_test();
ok(!(await engine._reconcile(localRecord)), "Skip incoming local if deleted");
});

39
services/sync/tests/unit/test_tab_store.js
Просмотреть файл

@ -6,23 +6,26 @@ Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
Cu.import("resource://testing-common/services/common/utils.js");
function getMockStore() {
async function getMockStore() {
let engine = new TabEngine(Service);
await engine.initialize();
let store = engine._store;
store.getTabState = mockGetTabState;
store.shouldSkipWindow = mockShouldSkipWindow;
return store;
}
function test_create() {
let store = new TabEngine(Service)._store;
add_task(async function test_create() {
let engine = new TabEngine(Service);
await engine.initialize();
let store = engine._store;
_("Create a first record");
let rec = {id: "id1",
clientName: "clientName1",
cleartext: { "foo": "bar" },
modified: 1000};
store.applyIncoming(rec);
await store.applyIncoming(rec);
deepEqual(store._remoteClients["id1"], { lastModified: 1000, foo: "bar" });
_("Create a second record");
@ -30,7 +33,7 @@ function test_create() {
clientName: "clientName2",
cleartext: { "foo2": "bar2" },
modified: 2000};
store.applyIncoming(rec);
await store.applyIncoming(rec);
deepEqual(store._remoteClients["id2"], { lastModified: 2000, foo2: "bar2" });
_("Create a third record");
@ -38,12 +41,12 @@ function test_create() {
clientName: "clientName3",
cleartext: { "foo3": "bar3" },
modified: 3000};
store.applyIncoming(rec);
await store.applyIncoming(rec);
deepEqual(store._remoteClients["id3"], { lastModified: 3000, foo3: "bar3" });
}
});
function test_getAllTabs() {
let store = getMockStore();
add_task(async function test_getAllTabs() {
let store = await getMockStore();
let tabs;
let threeUrls = ["http://foo.com", "http://fuubar.com", "http://barbar.com"];
@ -83,10 +86,10 @@ function test_getAllTabs() {
equal(tabs[0].urlHistory.length, 5);
equal(tabs[0].urlHistory[0], "http://foo40.bar");
equal(tabs[0].urlHistory[4], "http://foo36.bar");
}
});
function test_createRecord() {
let store = getMockStore();
add_task(async function test_createRecord() {
let store = await getMockStore();
let record;
store.getTabState = mockGetTabState;
@ -96,19 +99,13 @@ function test_createRecord() {
let numtabs = 2600; // Note: this number is connected to DEFAULT_MAX_RECORD_PAYLOAD_BYTES
store.getWindowEnumerator = mockGetWindowEnumerator.bind(this, "http://foo.com", 1, 1);
record = store.createRecord("fake-guid");
record = await store.createRecord("fake-guid");
ok(record instanceof TabSetRecord);
equal(record.tabs.length, 1);
_("create a big record");
store.getWindowEnumerator = mockGetWindowEnumerator.bind(this, "http://foo.com", 1, numtabs);
record = store.createRecord("fake-guid");
record = await store.createRecord("fake-guid");
ok(record instanceof TabSetRecord);
equal(record.tabs.length, 2501);
}
function run_test() {
test_create();
test_getAllTabs();
test_createRecord();
}
});

19
services/sync/tests/unit/test_tab_tracker.js
Просмотреть файл

@ -5,7 +5,12 @@ Cu.import("resource://services-sync/engines/tabs.js");
Cu.import("resource://services-sync/service.js");
Cu.import("resource://services-sync/util.js");
var clientsEngine = Service.clientsEngine;
let clientsEngine;
add_task(async function setup() {
await Service.promiseInitialized;
clientsEngine = Service.clientsEngine;
});
function fakeSvcWinMediator() {
// actions on windows are captured in logs
@ -44,7 +49,7 @@ function fakeSvcWinMediator() {
return logs;
}
function run_test() {
add_task(async function run_test() {
let engine = Service.engineManager.get("tabs");
_("We assume that tabs have changed at startup.");
@ -52,7 +57,7 @@ function run_test() {
tracker.persistChangedIDs = false;
do_check_true(tracker.modified);
do_check_true(Utils.deepEquals(Object.keys(engine.getChangedIDs()),
do_check_true(Utils.deepEquals(Object.keys((await engine.getChangedIDs())),
[clientsEngine.localID]));
let logs;
@ -98,7 +103,7 @@ function run_test() {
// Send a fake tab event
tracker.onTab({type: evttype, originalTarget: evttype});
do_check_true(tracker.modified);
do_check_true(Utils.deepEquals(Object.keys(engine.getChangedIDs()),
do_check_true(Utils.deepEquals(Object.keys((await engine.getChangedIDs())),
[clientsEngine.localID]));
}
@ -107,7 +112,7 @@ function run_test() {
do_check_false(tracker.modified);
tracker.onTab({type: "pageshow", originalTarget: "pageshow"});
do_check_true(Utils.deepEquals(Object.keys(engine.getChangedIDs()),
do_check_true(Utils.deepEquals(Object.keys((await engine.getChangedIDs())),
[clientsEngine.localID]));
// Pretend we just synced and saw some progress listeners.
@ -122,6 +127,6 @@ function run_test() {
tracker.onLocationChange({ isTopLevel: true }, undefined, undefined, 0);
do_check_true(tracker.modified, "location change for a new top-level document flagged as modified");
do_check_true(Utils.deepEquals(Object.keys(engine.getChangedIDs()),
do_check_true(Utils.deepEquals(Object.keys((await engine.getChangedIDs())),
[clientsEngine.localID]));
}
});

44
services/sync/tests/unit/test_telemetry.js
Просмотреть файл

@ -17,7 +17,6 @@ Cu.import("resource://gre/modules/osfile.jsm", this);
Cu.import("resource://services-sync/util.js");
initTestLogging("Trace");
function SteamStore(engine) {
Store.call(this, "Steam", engine);
@ -45,7 +44,7 @@ SteamEngine.prototype = {
_storeObj: SteamStore,
_trackerObj: SteamTracker,
_errToThrow: null,
_sync() {
async _sync() {
if (this._errToThrow) {
throw this._errToThrow;
}
@ -66,8 +65,11 @@ async function cleanAndGo(engine, server) {
await promiseStopServer(server);
}
// Avoid addon manager complaining about not being initialized
Service.engineManager.unregister("addons");
add_task(async function setup() {
initTestLogging("Trace");
// Avoid addon manager complaining about not being initialized
Service.engineManager.unregister("addons");
});
add_task(async function test_basic() {
enableValidationPrefs();
@ -105,6 +107,7 @@ add_task(async function test_basic() {
add_task(async function test_processIncoming_error() {
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -148,13 +151,14 @@ add_task(async function test_processIncoming_error() {
});
} finally {
store.wipe();
await store.wipe();
await cleanAndGo(engine, server);
}
});
add_task(async function test_uploading() {
let engine = new BookmarksEngine(Service);
await engine.initialize();
let store = engine._store;
let server = serverForFoo(engine);
await SyncTestingInfrastructure(server);
@ -176,8 +180,8 @@ add_task(async function test_uploading() {
PlacesUtils.bookmarks.setItemTitle(bmk_id, "New Title");
store.wipe();
engine.resetClient();
await store.wipe();
await engine.resetClient();
ping = await sync_engine_and_validate_telem(engine, false);
equal(ping.engines.length, 1);
@ -187,7 +191,7 @@ add_task(async function test_uploading() {
} finally {
// Clean up.
store.wipe();
await store.wipe();
await cleanAndGo(engine, server);
}
});
@ -333,7 +337,7 @@ add_task(async function test_sync_partialUpload() {
add_task(async function test_generic_engine_fail() {
enableValidationPrefs();
Service.engineManager.register(SteamEngine);
await Service.engineManager.register(SteamEngine);
let engine = Service.engineManager.get("steam");
engine.enabled = true;
let server = serverForFoo(engine);
@ -359,7 +363,7 @@ add_task(async function test_generic_engine_fail() {
add_task(async function test_engine_fail_ioerror() {
enableValidationPrefs();
Service.engineManager.register(SteamEngine);
await Service.engineManager.register(SteamEngine);
let engine = Service.engineManager.get("steam");
engine.enabled = true;
let server = serverForFoo(engine);
@ -426,7 +430,7 @@ add_task(async function test_clean_urls() {
add_task(async function test_initial_sync_engines() {
enableValidationPrefs();
Service.engineManager.register(SteamEngine);
await Service.engineManager.register(SteamEngine);
let engine = Service.engineManager.get("steam");
engine.enabled = true;
// These are the only ones who actually have things to sync at startup.
@ -463,7 +467,7 @@ add_task(async function test_initial_sync_engines() {
add_task(async function test_nserror() {
enableValidationPrefs();
Service.engineManager.register(SteamEngine);
await Service.engineManager.register(SteamEngine);
let engine = Service.engineManager.get("steam");
engine.enabled = true;
let server = serverForFoo(engine);
@ -518,7 +522,7 @@ add_task(async function test_discarding() {
telem.submit = () => ok(false, "Submitted telemetry ping when we should not have");
for (let i = 0; i < 5; ++i) {
Service.sync();
await Service.sync();
}
telem.submit = oldSubmit;
telem.submissionInterval = -1;
@ -538,7 +542,7 @@ add_task(async function test_discarding() {
add_task(async function test_no_foreign_engines_in_error_ping() {
enableValidationPrefs();
Service.engineManager.register(BogusEngine);
await Service.engineManager.register(BogusEngine);
let engine = Service.engineManager.get("bogus");
engine.enabled = true;
let server = serverForFoo(engine);
@ -557,7 +561,7 @@ add_task(async function test_no_foreign_engines_in_error_ping() {
add_task(async function test_sql_error() {
enableValidationPrefs();
Service.engineManager.register(SteamEngine);
await Service.engineManager.register(SteamEngine);
let engine = Service.engineManager.get("steam");
engine.enabled = true;
let server = serverForFoo(engine);
@ -582,7 +586,7 @@ add_task(async function test_sql_error() {
add_task(async function test_no_foreign_engines_in_success_ping() {
enableValidationPrefs();
Service.engineManager.register(BogusEngine);
await Service.engineManager.register(BogusEngine);
let engine = Service.engineManager.get("bogus");
engine.enabled = true;
let server = serverForFoo(engine);
@ -600,7 +604,7 @@ add_task(async function test_no_foreign_engines_in_success_ping() {
add_task(async function test_events() {
enableValidationPrefs();
Service.engineManager.register(BogusEngine);
await Service.engineManager.register(BogusEngine);
let engine = Service.engineManager.get("bogus");
engine.enabled = true;
let server = serverForFoo(engine);
@ -644,7 +648,7 @@ add_task(async function test_events() {
add_task(async function test_invalid_events() {
enableValidationPrefs();
Service.engineManager.register(BogusEngine);
await Service.engineManager.register(BogusEngine);
let engine = Service.engineManager.get("bogus");
engine.enabled = true;
let server = serverForFoo(engine);
@ -690,7 +694,7 @@ add_task(async function test_no_ping_for_self_hosters() {
let telem = get_sync_test_telemetry();
let oldSubmit = telem.submit;
Service.engineManager.register(BogusEngine);
await Service.engineManager.register(BogusEngine);
let engine = Service.engineManager.get("bogus");
engine.enabled = true;
let server = serverForFoo(engine);
@ -703,7 +707,7 @@ add_task(async function test_no_ping_for_self_hosters() {
resolve(result);
};
});
Service.sync();
await Service.sync();
let pingSubmitted = await submitPromise;
// The Sync testing infrastructure already sets up a custom token server,
// so we don't need to do anything to simulate a self-hosted user.

47
services/sync/tests/unit/test_utils_catch.js
Просмотреть файл

@ -1,11 +1,11 @@
Cu.import("resource://services-sync/util.js");
Cu.import("resource://services-sync/service.js");
function run_test() {
add_task(async function run_test() {
_("Make sure catch when copied to an object will correctly catch stuff");
let ret, rightThis, didCall, didThrow, wasTen, wasLocked;
let obj = {
catch: Utils.catch,
_catch: Utils.catch,
_log: {
debug(str) {
didThrow = str.search(/^Exception/) == 0;
@ -16,7 +16,7 @@ function run_test() {
},
func() {
return this.catch(function() {
return this._catch(async function() {
rightThis = this == obj;
didCall = true;
return 5;
@ -24,7 +24,7 @@ function run_test() {
},
throwy() {
return this.catch(function() {
return this._catch(async function() {
rightThis = this == obj;
didCall = true;
throw 10;
@ -32,27 +32,35 @@ function run_test() {
},
callbacky() {
return this.catch(function() {
return this._catch(async function() {
rightThis = this == obj;
didCall = true;
throw 10;
}, function(ex) {
}, async function(ex) {
wasTen = (ex == 10)
})();
},
lockedy() {
return this.catch(function() {
return this._catch(async function() {
rightThis = this == obj;
didCall = true;
throw ("Could not acquire lock.");
})();
}
},
lockedy_chained() {
return this._catch(function() {
rightThis = this == obj;
didCall = true;
return Promise.resolve().then( () => { throw ("Could not acquire lock.") });
})();
},
};
_("Make sure a normal call will call and return");
rightThis = didCall = didThrow = wasLocked = false;
ret = obj.func();
ret = await obj.func();
do_check_eq(ret, 5);
do_check_true(rightThis);
do_check_true(didCall);
@ -62,7 +70,7 @@ function run_test() {
_("Make sure catch/throw results in debug call and caller doesn't need to handle exception");
rightThis = didCall = didThrow = wasLocked = false;
ret = obj.throwy();
ret = await obj.throwy();
do_check_eq(ret, undefined);
do_check_true(rightThis);
do_check_true(didCall);
@ -72,7 +80,7 @@ function run_test() {
_("Test callback for exception testing.");
rightThis = didCall = didThrow = wasLocked = false;
ret = obj.callbacky();
ret = await obj.callbacky();
do_check_eq(ret, undefined);
do_check_true(rightThis);
do_check_true(didCall);
@ -81,14 +89,25 @@ function run_test() {
do_check_false(wasLocked);
_("Test the lock-aware catch that Service uses.");
obj.catch = Service._catch;
obj._catch = Service._catch;
rightThis = didCall = didThrow = wasLocked = false;
wasTen = undefined;
ret = obj.lockedy();
ret = await obj.lockedy();
do_check_eq(ret, undefined);
do_check_true(rightThis);
do_check_true(didCall);
do_check_true(didThrow);
do_check_eq(wasTen, undefined);
do_check_true(wasLocked);
}
_("Test the lock-aware catch that Service uses with a chained promise.");
rightThis = didCall = didThrow = wasLocked = false;
wasTen = undefined;
ret = await obj.lockedy_chained();
do_check_eq(ret, undefined);
do_check_true(rightThis);
do_check_true(didCall);
do_check_true(didThrow);
do_check_eq(wasTen, undefined);
do_check_true(wasLocked);
});

91
services/sync/tests/unit/test_utils_json.js
Просмотреть файл

@ -4,76 +4,53 @@
Cu.import("resource://gre/modules/FileUtils.jsm");
Cu.import("resource://services-sync/util.js");
function run_test() {
initTestLogging();
run_next_test();
}
initTestLogging();
add_test(function test_roundtrip() {
add_task(async function test_roundtrip() {
_("Do a simple write of an array to json and read");
Utils.jsonSave("foo", {}, ["v1", "v2"], ensureThrows(function(error) {
do_check_eq(error, null);
await Utils.jsonSave("foo", {}, ["v1", "v2"]);
Utils.jsonLoad("foo", {}, ensureThrows(function(val) {
let foo = val;
do_check_eq(typeof foo, "object");
do_check_eq(foo.length, 2);
do_check_eq(foo[0], "v1");
do_check_eq(foo[1], "v2");
run_next_test();
}));
}));
let foo = await Utils.jsonLoad("foo", {});
do_check_eq(typeof foo, "object");
do_check_eq(foo.length, 2);
do_check_eq(foo[0], "v1");
do_check_eq(foo[1], "v2");
});
add_test(function test_string() {
add_task(async function test_string() {
_("Try saving simple strings");
Utils.jsonSave("str", {}, "hi", ensureThrows(function(error) {
do_check_eq(error, null);
await Utils.jsonSave("str", {}, "hi");
Utils.jsonLoad("str", {}, ensureThrows(function(val) {
let str = val;
do_check_eq(typeof str, "string");
do_check_eq(str.length, 2);
do_check_eq(str[0], "h");
do_check_eq(str[1], "i");
run_next_test();
}));
}));
let str = await Utils.jsonLoad("str", {});
do_check_eq(typeof str, "string");
do_check_eq(str.length, 2);
do_check_eq(str[0], "h");
do_check_eq(str[1], "i");
});
add_test(function test_number() {
add_task(async function test_number() {
_("Try saving a number");
Utils.jsonSave("num", {}, 42, ensureThrows(function(error) {
do_check_eq(error, null);
await Utils.jsonSave("num", {}, 42);
Utils.jsonLoad("num", {}, ensureThrows(function(val) {
let num = val;
do_check_eq(typeof num, "number");
do_check_eq(num, 42);
run_next_test();
}));
}));
let num = await Utils.jsonLoad("num", {});
do_check_eq(typeof num, "number");
do_check_eq(num, 42);
});
add_test(function test_nonexistent_file() {
add_task(async function test_nonexistent_file() {
_("Try loading a non-existent file.");
Utils.jsonLoad("non-existent", {}, ensureThrows(function(val) {
do_check_eq(val, undefined);
run_next_test();
}));
let val = await Utils.jsonLoad("non-existent", {});
do_check_eq(val, undefined);
});
add_test(function test_save_logging() {
add_task(async function test_save_logging() {
_("Verify that writes are logged.");
let trace;
Utils.jsonSave("log", {_log: {trace(msg) { trace = msg; }}},
"hi", ensureThrows(function() {
do_check_true(!!trace);
run_next_test();
}));
await Utils.jsonSave("log", {_log: {trace(msg) { trace = msg; }}}, "hi");
do_check_true(!!trace);
});
add_test(function test_load_logging() {
add_task(async function test_load_logging() {
_("Verify that reads and read errors are logged.");
// Write a file with some invalid JSON
@ -101,14 +78,8 @@ add_test(function test_load_logging() {
}
}
};
Utils.jsonLoad("log", obj, ensureThrows(function(val) {
do_check_true(!val);
do_check_true(!!trace);
do_check_true(!!debug);
run_next_test();
}));
});
add_task(async function test_undefined_callback() {
await Utils.jsonSave("foo", {}, ["v1", "v2"]);
let val = await Utils.jsonLoad("log", obj);
do_check_true(!val);
do_check_true(!!trace);
do_check_true(!!debug);
});

28
services/sync/tests/unit/test_utils_lock.js
Просмотреть файл

@ -8,7 +8,7 @@ function do_check_begins(thing, startsWith) {
do_throw(thing + " doesn't begin with " + startsWith);
}
function run_test() {
add_task(async function run_test() {
let ret, rightThis, didCall;
let state, lockState, lockedState, unlockState;
let obj = {
@ -29,27 +29,27 @@ function run_test() {
func() {
return this._lock("Test utils lock",
function() {
rightThis = this == obj;
didCall = true;
return 5;
})();
async function() {
rightThis = this == obj;
didCall = true;
return 5;
})();
},
throwy() {
return this._lock("Test utils lock throwy",
function() {
rightThis = this == obj;
didCall = true;
this.throwy();
})();
async function() {
rightThis = this == obj;
didCall = true;
return this.throwy();
})();
}
};
_("Make sure a normal call will call and return");
rightThis = didCall = false;
state = 0;
ret = obj.func();
ret = await obj.func();
do_check_eq(ret, 5);
do_check_true(rightThis);
do_check_true(didCall);
@ -61,7 +61,7 @@ function run_test() {
ret = null;
rightThis = didCall = false;
try {
ret = obj.throwy();
ret = await obj.throwy();
do_throw("throwy internal call should have thrown!");
} catch (ex) {
// Should throw an Error, not a string.
@ -75,4 +75,4 @@ function run_test() {
do_check_eq(lockedState, 5);
do_check_eq(unlockState, 6);
do_check_eq(state, 6);
}
});

12
services/sync/tests/unit/test_utils_notify.js
Просмотреть файл

@ -1,7 +1,7 @@
_("Make sure notify sends out the right notifications");
Cu.import("resource://services-sync/util.js");
function run_test() {
add_task(async function run_test() {
let ret, rightThis, didCall;
let obj = {
notify: Utils.notify("foo:"),
@ -10,7 +10,7 @@ function run_test() {
},
func() {
return this.notify("bar", "baz", function() {
return this.notify("bar", "baz", async function() {
rightThis = this == obj;
didCall = true;
return 5;
@ -18,7 +18,7 @@ function run_test() {
},
throwy() {
return this.notify("bad", "one", function() {
return this.notify("bad", "one", async function() {
rightThis = this == obj;
didCall = true;
throw 10;
@ -46,7 +46,7 @@ function run_test() {
let fs = makeObs("foo:bar:start");
let ff = makeObs("foo:bar:finish");
let fe = makeObs("foo:bar:error");
ret = obj.func();
ret = await obj.func();
do_check_eq(ret, 5);
do_check_true(rightThis);
do_check_true(didCall);
@ -73,7 +73,7 @@ function run_test() {
let tf = makeObs("foo:bad:finish");
let te = makeObs("foo:bad:error");
try {
ret = obj.throwy();
ret = await obj.throwy();
do_throw("throwy should have thrown!");
} catch (ex) {
do_check_eq(ex, 10);
@ -96,4 +96,4 @@ function run_test() {
do_check_eq(te.subject, 10);
do_check_eq(te.topic, "foo:bad:error");
do_check_eq(te.data, "one");
}
});

2
services/sync/tps/extensions/tps/resource/auth/fxaccounts.jsm
Просмотреть файл

@ -195,7 +195,7 @@ var Authentication = {
if (Weave.Status.login !== Weave.LOGIN_SUCCEEDED) {
Logger.logInfo("Logging into Weave.");
Weave.Service.login();
Async.promiseSpinningly(Weave.Service.login());
Logger.AssertEqual(Weave.Status.login, Weave.LOGIN_SUCCEEDED,
"Weave logged in");
}

14
services/sync/tps/extensions/tps/resource/modules/addons.jsm
Просмотреть файл

@ -54,21 +54,13 @@ Addon.prototype = {
uninstall: function uninstall() {
// find our addon locally
let cb = Async.makeSyncCallback();
AddonManager.getAddonByID(this.id, cb);
let addon = Async.waitForSyncCallback(cb);
let addon = Async.promiseSpinningly(AddonManager.getAddonByID(this.id));
Logger.AssertTrue(!!addon, "could not find addon " + this.id + " to uninstall");
cb = Async.makeSpinningCallback();
AddonUtils.uninstallAddon(addon, cb);
cb.wait();
Async.promiseSpinningly(AddonUtils.uninstallAddon(addon));
},
find: function find(state) {
let cb = Async.makeSyncCallback();
AddonManager.getAddonByID(this.id, cb);
let addon = Async.waitForSyncCallback(cb);
let addon = Async.promiseSpinningly(AddonManager.getAddonByID(this.id));
if (!addon) {
Logger.logInfo("Could not find add-on with ID: " + this.id);

9
services/sync/tps/extensions/tps/resource/tps.jsm
Просмотреть файл

@ -695,7 +695,7 @@ var TPS = {
// as above
serverRecordDumpStr = "<Cyclic value>";
}
let { problemData } = validator.compareClientWithServer(clientRecords, serverRecords);
let { problemData } = Async.promiseSpinningly(validator.compareClientWithServer(clientRecords, serverRecords));
for (let { name, count } of problemData.getSummary()) {
if (count) {
Logger.logInfo(`Validation problem: "${name}": ${JSON.stringify(problemData[name])}`);
@ -931,7 +931,6 @@ var TPS = {
for (let name of this._enabledEngines) {
names[name] = true;
}
for (let engine of Weave.Service.engineManager.getEnabled()) {
if (!(engine.name in names)) {
Logger.logInfo("Unregistering unused engine: " + engine.name);
@ -1181,7 +1180,7 @@ var TPS = {
this._triggeredSync = true;
this.StartAsyncOperation();
Weave.Service.sync();
Async.promiseSpinningly(Weave.Service.sync());
Logger.logInfo("Sync is complete");
},
@ -1189,8 +1188,8 @@ var TPS = {
Logger.logInfo("Wiping data from server.");
this.Login(false);
Weave.Service.login();
Weave.Service.wipeServer();
Async.promiseSpinningly(Weave.Service.login());
Async.promiseSpinningly(Weave.Service.wipeServer());
},
/**