--- a/services/sync/tests/unit/head_helpers.js
+++ b/services/sync/tests/unit/head_helpers.js
@@ -109,89 +109,76 @@ function webExtensionsTestPath(path) {
 function loadWebExtensionTestFunctions() {
   /* import-globals-from ../../../../toolkit/components/extensions/test/xpcshell/head_sync.js */
   const path = webExtensionsTestPath("/head_sync.js");
   let file = do_get_file(path);
   let uri = Services.io.newFileURI(file);
   Services.scriptloader.loadSubScript(uri.spec, gGlobalScope);
 }
 
+// Returns a promise
 function getAddonInstall(name) {
   let f = do_get_file(ExtensionsTestPath("/addons/" + name + ".xpi"));
-  let cb = Async.makeSyncCallback();
-  AddonManager.getInstallForFile(f, cb);
-
-  return Async.waitForSyncCallback(cb);
+  return AddonManager.getInstallForFile(f);
 }
 
 /**
- * Obtains an addon from the add-on manager by id.
- *
- * This is merely a synchronous wrapper.
- *
- * @param  id
- *         ID of add-on to fetch
- * @return addon object on success or undefined or null on failure
- */
-function getAddonFromAddonManagerByID(id) {
-   let cb = Async.makeSyncCallback();
-   AddonManager.getAddonByID(id, cb);
-   return Async.waitForSyncCallback(cb);
-}
-
-/**
- * Installs an add-on synchronously from an addonInstall
+ * Installs an add-on from an addonInstall
  *
  * @param  install addonInstall instance to install
  */
-function installAddonFromInstall(install) {
-  let cb = Async.makeSyncCallback();
-  let listener = {onInstallEnded: cb};
-  AddonManager.addInstallListener(listener);
-  install.install();
-  Async.waitForSyncCallback(cb);
-  AddonManager.removeAddonListener(listener);
+async function installAddonFromInstall(install) {
+  await new Promise(res => {
+    let listener = {
+      onInstallEnded() {
+        AddonManager.removeAddonListener(listener);
+        res();
+      }
+    };
+    AddonManager.addInstallListener(listener);
+    install.install();
+  });
 
   Assert.notEqual(null, install.addon);
   Assert.notEqual(null, install.addon.syncGUID);
 
   return install.addon;
 }
 
 /**
  * Convenience function to install an add-on from the extensions unit tests.
  *
  * @param  name
  *         String name of add-on to install. e.g. test_install1
  * @return addon object that was installed
  */
-function installAddon(name) {
-  let install = getAddonInstall(name);
+async function installAddon(name) {
+  let install = await getAddonInstall(name);
   Assert.notEqual(null, install);
   return installAddonFromInstall(install);
 }
 
 /**
- * Convenience function to uninstall an add-on synchronously.
+ * Convenience function to uninstall an add-on.
  *
  * @param addon
  *        Addon instance to uninstall
  */
 function uninstallAddon(addon) {
-  let cb = Async.makeSyncCallback();
-  let listener = {onUninstalled(uninstalled) {
-    if (uninstalled.id == addon.id) {
-      AddonManager.removeAddonListener(listener);
-      cb(uninstalled);
-    }
-  }};
+  return new Promise(res => {
+    let listener = {onUninstalled(uninstalled) {
+      if (uninstalled.id == addon.id) {
+        AddonManager.removeAddonListener(listener);
+        res(uninstalled);
+      }
+    }};
 
-  AddonManager.addAddonListener(listener);
-  addon.uninstall();
-  Async.waitForSyncCallback(cb);
+    AddonManager.addAddonListener(listener);
+    addon.uninstall();
+  });
 }
 
 async function generateNewKeys(collectionKeys, collections = null) {
   let wbo = await collectionKeys.generateNewKeysWBO(collections);
   let modified = new_timestamp();
   collectionKeys.setContents(wbo.cleartext, modified);
 }
 

--- a/services/sync/tests/unit/test_addons_engine.js
+++ b/services/sync/tests/unit/test_addons_engine.js
@@ -48,49 +48,49 @@ add_task(async function setup() {
   await resetReconciler();
 });
 
 // This is a basic sanity test for the unit test itself. If this breaks, the
 // add-ons API likely changed upstream.
 add_task(async function test_addon_install() {
   _("Ensure basic add-on APIs work as expected.");
 
-  let install = getAddonInstall("test_bootstrap1_1");
+  let install = await getAddonInstall("test_bootstrap1_1");
   Assert.notEqual(install, null);
   Assert.equal(install.type, "extension");
   Assert.equal(install.name, "Test Bootstrap 1");
 
   await resetReconciler();
 });
 
 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.
   await engine._refreshReconcilerState();
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
 
   let record = {
     id:            Utils.makeGUID(),
     addonID:       addon.id,
     enabled:       true,
     applicationID: Services.appinfo.ID,
     source:        "amo"
   };
 
   let dupe = await engine._findDupe(record);
   Assert.equal(addon.syncGUID, dupe);
 
   record.id = addon.syncGUID;
   dupe = await engine._findDupe(record);
   Assert.equal(null, dupe);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   await resetReconciler();
 });
 
 add_task(async function test_get_changed_ids() {
   _("Ensure getChangedIDs() has the appropriate behavior.");
 
   _("Ensure getChangedIDs() returns an empty object by default.");
   let changes = await engine.getChangedIDs();
@@ -107,28 +107,28 @@ add_task(async function test_get_changed
   Assert.equal("object", typeof(changes));
   Assert.equal(1, Object.keys(changes).length);
   Assert.ok(guid1 in changes);
   Assert.equal(changeTime, changes[guid1]);
 
   tracker.clearChangedIDs();
 
   _("Ensure reconciler changes are populated.");
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   tracker.clearChangedIDs(); // Just in case.
   changes = await engine.getChangedIDs();
   Assert.equal("object", typeof(changes));
   Assert.equal(1, Object.keys(changes).length);
   Assert.ok(addon.syncGUID in changes);
   _("Change time: " + changeTime + ", addon change: " + changes[addon.syncGUID]);
   Assert.ok(changes[addon.syncGUID] >= changeTime);
 
   let oldTime = changes[addon.syncGUID];
   let guid2 = addon.syncGUID;
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   changes = await engine.getChangedIDs();
   Assert.equal(1, Object.keys(changes).length);
   Assert.ok(guid2 in changes);
   Assert.ok(changes[guid2] > oldTime);
 
   _("Ensure non-syncable add-ons aren't picked up by reconciler changes.");
   reconciler._addons  = {};
   reconciler._changes = [];

--- a/services/sync/tests/unit/test_addons_reconciler.js
+++ b/services/sync/tests/unit/test_addons_reconciler.js
@@ -47,17 +47,17 @@ add_task(async function test_load_state_
 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();
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let after = new Date();
 
   Assert.equal(1, Object.keys(reconciler.addons).length);
   Assert.ok(addon.id in reconciler.addons);
   let record = reconciler.addons[addon.id];
 
   const KEYS = ["id", "guid", "enabled", "installed", "modified", "type",
                 "scope", "foreignInstall"];
@@ -75,34 +75,34 @@ add_task(async function test_install_det
   Assert.ok(!record.foreignInstall);
 
   Assert.equal(1, reconciler._changes.length);
   let change = reconciler._changes[0];
   Assert.ok(change[0] >= before && change[1] <= after);
   Assert.equal(CHANGE_INSTALLED, change[1]);
   Assert.equal(addon.id, change[2]);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 });
 
 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 = {};
   reconciler._changes = [];
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let id = addon.id;
 
   reconciler._changes = [];
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 
   Assert.equal(1, Object.keys(reconciler.addons).length);
   Assert.ok(id in reconciler.addons);
 
   let record = reconciler.addons[id];
   Assert.ok(!record.installed);
 
   Assert.equal(1, reconciler._changes.length);

--- a/services/sync/tests/unit/test_addons_store.js
+++ b/services/sync/tests/unit/test_addons_store.js
@@ -114,156 +114,156 @@ add_task(async function setup() {
   // Don't flush to disk in the middle of an event listener!
   // This causes test hangs on WinXP.
   reconciler._shouldPersist = false;
 });
 
 add_task(async function test_remove() {
   _("Ensure removing add-ons from deleted records works.");
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let record = createRecordForThisApp(addon.syncGUID, addon.id, true, true);
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(0, failed.length);
 
-  let newAddon = getAddonFromAddonManagerByID(addon.id);
+  let newAddon = await AddonManager.getAddonByID(addon.id);
   Assert.equal(null, newAddon);
 });
 
 add_task(async function test_apply_enabled() {
   _("Ensures that changes to the userEnabled flag apply.");
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   Assert.ok(addon.isActive);
   Assert.ok(!addon.userDisabled);
 
   _("Ensure application of a disable record works as expected.");
   let records = [];
   records.push(createRecordForThisApp(addon.syncGUID, addon.id, false, false));
   let failed = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(addon.userDisabled);
   checkReconcilerUpToDate(addon);
   records = [];
 
   _("Ensure enable record works as expected.");
   records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, false));
   failed = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(!addon.userDisabled);
   checkReconcilerUpToDate(addon);
   records = [];
 
   _("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 = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(!addon.userDisabled);
   records = [];
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   Svc.Prefs.reset("addons.ignoreUserEnabledChanges");
 });
 
 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.
+  let addon = await installAddon("test_install3"); // this addon is appDisabled by default.
   Assert.ok(addon.appDisabled);
   Assert.ok(!addon.isActive);
   Assert.ok(!addon.userDisabled);
 
   _("Ensure application of a disable record works as expected.");
   store.reconciler.pruneChangesBeforeDate(Date.now() + 10);
   store.reconciler._changes = [];
   let records = [];
   records.push(createRecordForThisApp(addon.syncGUID, addon.id, false, false));
   let failed = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(addon.userDisabled);
   checkReconcilerUpToDate(addon);
   records = [];
 
   _("Ensure enable record works as expected.");
   records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, false));
   failed = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(!addon.userDisabled);
   checkReconcilerUpToDate(addon);
   records = [];
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 });
 
 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.
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   Assert.ok(!addon.userDisabled);
 
   let record = createRecordForThisApp(addon.syncGUID, addon.id, false, false);
   record.applicationID = "FAKE_ID";
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(0, failed.length);
 
-  let newAddon = getAddonFromAddonManagerByID(addon.id);
+  let newAddon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(!newAddon.userDisabled);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 });
 
 add_task(async function test_ignore_unknown_source() {
   _("Ensure incoming records with unknown source are ignored.");
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
 
   let record = createRecordForThisApp(addon.syncGUID, addon.id, false, false);
   record.source = "DUMMY_SOURCE";
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(0, failed.length);
 
-  let newAddon = getAddonFromAddonManagerByID(addon.id);
+  let newAddon = await AddonManager.getAddonByID(addon.id);
   Assert.ok(!newAddon.userDisabled);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 });
 
 add_task(async function test_apply_uninstall() {
   _("Ensures that uninstalling an add-on from a record works.");
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
 
   let records = [];
   records.push(createRecordForThisApp(addon.syncGUID, addon.id, true, true));
   let failed = await store.applyIncomingBatch(records);
   Assert.equal(0, failed.length);
 
-  addon = getAddonFromAddonManagerByID(addon.id);
+  addon = await AddonManager.getAddonByID(addon.id);
   Assert.equal(null, addon);
 });
 
 add_task(async function test_addon_syncability() {
   _("Ensure isAddonSyncable functions properly.");
 
   Svc.Prefs.set("addons.trustedSourceHostnames",
                 "addons.mozilla.org,other.example.com");
 
   Assert.ok(!(await store.isAddonSyncable(null)));
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   Assert.ok((await store.isAddonSyncable(addon)));
 
   let dummy = {};
   const KEYS = ["id", "syncGUID", "type", "scope", "foreignInstall", "isSyncable"];
   for (let k of KEYS) {
     dummy[k] = addon[k];
   }
 
@@ -280,17 +280,17 @@ add_task(async function test_addon_synca
   dummy.isSyncable = false;
   Assert.ok(!(await store.isAddonSyncable(dummy)));
   dummy.isSyncable = addon.isSyncable;
 
   dummy.foreignInstall = true;
   Assert.ok(!(await store.isAddonSyncable(dummy)));
   dummy.foreignInstall = false;
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 
   Assert.ok(!store.isSourceURITrusted(null));
 
   let trusted = [
     "https://addons.mozilla.org/foo",
     "https://other.example.com/foo"
   ];
 
@@ -323,77 +323,77 @@ add_task(async function test_get_all_ids
   _("Ensures that getAllIDs() returns an appropriate set.");
 
   _("Installing two addons.");
   // XXX - this test seems broken - at this point, before we've installed the
   // addons below, store.getAllIDs() returns all addons installed by previous
   // tests, even though those tests uninstalled the addon.
   // So if any tests above ever add a new addon ID, they are going to need to
   // be added here too.
-  // do_check_eq(0, Object.keys(store.getAllIDs()).length);
-  let addon1 = installAddon("test_install1");
-  let addon2 = installAddon("test_bootstrap1_1");
-  let addon3 = installAddon("test_install3");
+  // Assert.equal(0, Object.keys(store.getAllIDs()).length);
+  let addon1 = await installAddon("test_install1");
+  let addon2 = await installAddon("test_bootstrap1_1");
+  let addon3 = await installAddon("test_install3");
 
   _("Ensure they're syncable.");
   Assert.ok((await store.isAddonSyncable(addon1)));
   Assert.ok((await store.isAddonSyncable(addon2)));
   Assert.ok((await store.isAddonSyncable(addon3)));
 
   let ids = await store.getAllIDs();
 
   Assert.equal("object", typeof(ids));
   Assert.equal(3, Object.keys(ids).length);
   Assert.ok(addon1.syncGUID in ids);
   Assert.ok(addon2.syncGUID in ids);
   Assert.ok(addon3.syncGUID in ids);
 
   addon1.install.cancel();
-  uninstallAddon(addon2);
-  uninstallAddon(addon3);
+  await uninstallAddon(addon2);
+  await uninstallAddon(addon3);
 });
 
 add_task(async function test_change_item_id() {
   _("Ensures that changeItemID() works properly.");
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
 
   let oldID = addon.syncGUID;
   let newID = Utils.makeGUID();
 
   await store.changeItemID(oldID, newID);
 
-  let newAddon = getAddonFromAddonManagerByID(addon.id);
+  let newAddon = await AddonManager.getAddonByID(addon.id);
   Assert.notEqual(null, newAddon);
   Assert.equal(newID, newAddon.syncGUID);
 
-  uninstallAddon(newAddon);
+  await uninstallAddon(newAddon);
 });
 
 add_task(async function test_create() {
   _("Ensure creating/installing an add-on from a record works.");
 
   let server = createAndStartHTTPServer(HTTP_PORT);
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let id = addon.id;
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
 
   let guid = Utils.makeGUID();
   let record = createRecordForThisApp(guid, id, true, false);
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(0, failed.length);
 
-  let newAddon = getAddonFromAddonManagerByID(id);
+  let newAddon = await AddonManager.getAddonByID(id);
   Assert.notEqual(null, newAddon);
   Assert.equal(guid, newAddon.syncGUID);
   Assert.ok(!newAddon.userDisabled);
 
-  uninstallAddon(newAddon);
+  await uninstallAddon(newAddon);
 
   await promiseStopServer(server);
 });
 
 add_task(async function test_create_missing_search() {
   _("Ensures that failed add-on searches are handled gracefully.");
 
   let server = createAndStartHTTPServer(HTTP_PORT);
@@ -402,17 +402,17 @@ add_task(async function test_create_miss
   const id = "missing@tests.mozilla.org";
   let guid = Utils.makeGUID();
   let record = createRecordForThisApp(guid, id, true, false);
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(1, failed.length);
   Assert.equal(guid, failed[0]);
 
-  let addon = getAddonFromAddonManagerByID(id);
+  let addon = await AddonManager.getAddonByID(id);
   Assert.equal(null, addon);
 
   await promiseStopServer(server);
 });
 
 add_task(async function test_create_bad_install() {
   _("Ensures that add-ons without a valid install are handled gracefully.");
 
@@ -430,19 +430,19 @@ add_task(async function test_create_bad_
   // was not being installed due to requireSecureURL checking *before* we'd
   // attempted to get the XPI.
   // With requireSecureURL disabled we do see a download failure, but the addon
   // *does* get added to |failed|.
   // FTR: onDownloadFailed() is called with ERROR_NETWORK_FAILURE, so it's going
   // to be tricky to distinguish a 404 from other transient network errors
   // where we do want the addon to end up in |failed|.
   // This is being tracked in bug 1284778.
-  // do_check_eq(0, failed.length);
+  // Assert.equal(0, failed.length);
 
-  let addon = getAddonFromAddonManagerByID(id);
+  let addon = await AddonManager.getAddonByID(id);
   Assert.equal(null, addon);
 
   await promiseStopServer(server);
 });
 
 add_task(async function test_ignore_system() {
   _("Ensure we ignore system addons");
   // Our system addon should not appear in getAllIDs
@@ -459,70 +459,69 @@ add_task(async function test_ignore_syst
 
 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
   // to this.
 
   // before we start, ensure the system addon isn't disabled.
-  Assert.ok(!getAddonFromAddonManagerByID(SYSTEM_ADDON_ID).userDisabled);
+  Assert.ok(!(await AddonManager.getAddonByID(SYSTEM_ADDON_ID).userDisabled));
 
   // Now simulate an incoming record with the same ID as the system addon,
   // but flagged as disabled - it should not be applied.
   let server = createAndStartHTTPServer(HTTP_PORT);
   // We make the incoming record flag the system addon as disabled - it should
   // be ignored.
   let guid = Utils.makeGUID();
   let record = createRecordForThisApp(guid, SYSTEM_ADDON_ID, false, false);
 
   let failed = await store.applyIncomingBatch([record]);
   Assert.equal(0, failed.length);
 
   // The system addon should still not be userDisabled.
-  Assert.ok(!getAddonFromAddonManagerByID(SYSTEM_ADDON_ID).userDisabled);
+  Assert.ok(!(await AddonManager.getAddonByID(SYSTEM_ADDON_ID).userDisabled));
 
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipe() {
   _("Ensures that wiping causes add-ons to be uninstalled.");
 
-  let addon1 = installAddon("test_bootstrap1_1");
+  let addon1 = await installAddon("test_bootstrap1_1");
 
   await store.wipe();
 
-  let addon = getAddonFromAddonManagerByID(addon1.id);
+  let addon = await AddonManager.getAddonByID(addon1.id);
   Assert.equal(null, addon);
 });
 
 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
   // receiving client will see a wipe followed by a record which should undo
   // the wipe.
-  let installed = installAddon("test_bootstrap1_1");
+  let installed = await installAddon("test_bootstrap1_1");
 
   let record = createRecordForThisApp(installed.syncGUID, installed.id, true,
                                       false);
 
   await store.wipe();
 
-  let deleted = getAddonFromAddonManagerByID(installed.id);
+  let deleted = await AddonManager.getAddonByID(installed.id);
   Assert.equal(null, deleted);
 
   // Re-applying the record can require re-fetching the XPI.
   let server = createAndStartHTTPServer(HTTP_PORT);
 
   await store.applyIncoming(record);
 
-  let fetched = getAddonFromAddonManagerByID(record.addonID);
+  let fetched = await AddonManager.getAddonByID(record.addonID);
   Assert.ok(!!fetched);
 
   await promiseStopServer(server);
 });
 
-add_test(function cleanup() {
+add_task(async function cleanup() {
   // There's an xpcom-shutdown hook for this, but let's give this a shot.
   reconciler.stopListening();
-  run_next_test();
 });

--- a/services/sync/tests/unit/test_addons_tracker.js
+++ b/services/sync/tests/unit/test_addons_tracker.js
@@ -52,70 +52,70 @@ add_task(async function test_empty() {
   Assert.equal(0, tracker.score);
 
   await cleanup();
 });
 
 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");
-  uninstallAddon(addon);
+  let addon = await installAddon("test_bootstrap1_1");
+  await uninstallAddon(addon);
 
   Assert.equal(0, Object.keys(tracker.changedIDs).length);
   Assert.equal(0, tracker.score);
 
   await cleanup();
 });
 
 add_task(async function test_track_install() {
   _("Ensure that installing an add-on notifies tracker.");
 
   reconciler.startListening();
 
   Svc.Obs.notify("weave:engine:start-tracking");
 
   Assert.equal(0, tracker.score);
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let changed = tracker.changedIDs;
 
   Assert.equal(1, Object.keys(changed).length);
   Assert.ok(addon.syncGUID in changed);
   Assert.equal(SCORE_INCREMENT_XLARGE, tracker.score);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   await cleanup();
 });
 
 add_task(async function test_track_uninstall() {
   _("Ensure that uninstalling an add-on notifies tracker.");
 
   reconciler.startListening();
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   let guid = addon.syncGUID;
   Assert.equal(0, tracker.score);
 
   Svc.Obs.notify("weave:engine:start-tracking");
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   let changed = tracker.changedIDs;
   Assert.equal(1, Object.keys(changed).length);
   Assert.ok(guid in changed);
   Assert.equal(SCORE_INCREMENT_XLARGE, tracker.score);
 
   await cleanup();
 });
 
 add_task(async function test_track_user_disable() {
   _("Ensure that tracker sees disabling of add-on");
 
   reconciler.startListening();
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   Assert.ok(!addon.userDisabled);
   Assert.ok(!addon.appDisabled);
   Assert.ok(addon.isActive);
 
   Svc.Obs.notify("weave:engine:start-tracking");
   Assert.equal(0, tracker.score);
 
   let disabledPromise = new Promise(res => {
@@ -139,35 +139,35 @@ add_task(async function test_track_user_
   _("Disabling started...");
   await disabledPromise;
 
   let changed = tracker.changedIDs;
   Assert.equal(1, Object.keys(changed).length);
   Assert.ok(addon.syncGUID in changed);
   Assert.equal(SCORE_INCREMENT_XLARGE, tracker.score);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   await cleanup();
 });
 
 add_task(async function test_track_enable() {
   _("Ensure that enabling a disabled add-on notifies tracker.");
 
   reconciler.startListening();
 
-  let addon = installAddon("test_bootstrap1_1");
+  let addon = await installAddon("test_bootstrap1_1");
   addon.userDisabled = true;
   await Async.promiseYield();
 
   Assert.equal(0, tracker.score);
 
   Svc.Obs.notify("weave:engine:start-tracking");
   addon.userDisabled = false;
   await Async.promiseYield();
 
   let changed = tracker.changedIDs;
   Assert.equal(1, Object.keys(changed).length);
   Assert.ok(addon.syncGUID in changed);
   Assert.equal(SCORE_INCREMENT_XLARGE, tracker.score);
 
-  uninstallAddon(addon);
+  await uninstallAddon(addon);
   await cleanup();
 });