--- a/services/sync/tests/unit/head_appinfo.js
+++ b/services/sync/tests/unit/head_appinfo.js
@@ -14,22 +14,16 @@ gSyncProfile = do_get_profile();
 // Init FormHistoryStartup and pretend we opened a profile.
 var fhs = Cc["@mozilla.org/satchel/form-history-startup;1"]
             .getService(Ci.nsIObserver);
 fhs.observe(null, "profile-after-change", null);
 
 // An app is going to have some prefs set which xpcshell tests don't.
 Services.prefs.setCharPref("identity.sync.tokenserver.uri", "http://token-server");
 
-// Set the validation prefs to attempt bookmark validation every time to avoid non-determinism.
-Services.prefs.setIntPref("services.sync.engine.bookmarks.validation.interval", 0);
-Services.prefs.setIntPref("services.sync.engine.bookmarks.validation.percentageChance", 100);
-Services.prefs.setIntPref("services.sync.engine.bookmarks.validation.maxRecords", -1);
-Services.prefs.setBoolPref("services.sync.engine.bookmarks.validation.enabled", true);
-
 // Make sure to provide the right OS so crypto loads the right binaries
 function getOS() {
   switch (mozinfo.os) {
     case "win":
       return "WINNT";
     case "mac":
       return "Darwin";
     default:

--- a/services/sync/tests/unit/head_helpers.js
+++ b/services/sync/tests/unit/head_helpers.js
@@ -488,8 +488,16 @@ function registerRotaryEngine() {
   Service.engineManager.clear();
 
   Service.engineManager.register(RotaryEngine);
   let engine = Service.engineManager.get("rotary");
   engine.enabled = true;
 
   return { engine, tracker: engine._tracker };
 }
+
+// Set the validation prefs to attempt validation every time to avoid non-determinism.
+function enableValidationPrefs() {
+  Svc.Prefs.set("engine.bookmarks.validation.interval", 0);
+  Svc.Prefs.set("engine.bookmarks.validation.percentageChance", 100);
+  Svc.Prefs.set("engine.bookmarks.validation.maxRecords", -1);
+  Svc.Prefs.set("engine.bookmarks.validation.enabled", true);
+}

--- a/services/sync/tests/unit/test_bookmark_engine.js
+++ b/services/sync/tests/unit/test_bookmark_engine.js
@@ -112,16 +112,18 @@ add_task(async function test_change_duri
 
   let bz_id = PlacesUtils.bookmarks.insertBookmark(
     PlacesUtils.bookmarksMenuFolderId, Utils.makeURI("https://bugzilla.mozilla.org/"),
     PlacesUtils.bookmarks.DEFAULT_INDEX, "Bugzilla");
   let bz_guid = await PlacesUtils.promiseItemGuid(bz_id);
     _(`Bugzilla GUID: ${bz_guid}`);
 
   await PlacesTestUtils.markBookmarksAsSynced();
+  enableValidationPrefs();
+
   Svc.Obs.notify("weave:engine:start-tracking");
 
   try {
     let folder1_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.toolbarFolder, "Folder 1", 0);
     let folder1_guid = store.GUIDForId(folder1_id);
     _(`Folder GUID: ${folder1_guid}`);
 

--- a/services/sync/tests/unit/test_bookmark_repair.js
+++ b/services/sync/tests/unit/test_bookmark_repair.js
@@ -53,16 +53,18 @@ async function cleanup(server) {
   bookmarksEngine._store.wipe();
   clientsEngine._store.wipe();
   Svc.Prefs.resetBranch("");
   Service.recordManager.clearCache();
   await promiseStopServer(server);
 }
 
 add_task(async function test_something() {
+  enableValidationPrefs();
+
   _("Ensure that a validation error triggers a repair request.");
 
   let contents = {
     meta: {
       global: {
         engines: {
           clients: {
             version: clientsEngine.version,

--- a/services/sync/tests/unit/test_collections_recovery.js
+++ b/services/sync/tests/unit/test_collections_recovery.js
@@ -2,16 +2,18 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 // Verify that we wipe the server if we have to regenerate keys.
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
 
 add_task(async function test_missing_crypto_collection() {
+  enableValidationPrefs();
+
   let johnHelper = track_collections_helper();
   let johnU      = johnHelper.with_updated_collection;
   let johnColls  = johnHelper.collections;
 
   let empty = false;
   function maybe_empty(handler) {
     return function(request, response) {
       if (empty) {

--- a/services/sync/tests/unit/test_corrupt_keys.js
+++ b/services/sync/tests/unit/test_corrupt_keys.js
@@ -9,16 +9,18 @@ Cu.import("resource://services-sync/engi
 Cu.import("resource://services-sync/engines/history.js");
 Cu.import("resource://services-sync/record.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/status.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
 
 add_task(async function test_locally_changed_keys() {
+  enableValidationPrefs();
+
   let hmacErrorCount = 0;
   function counting(f) {
     return function() {
       hmacErrorCount++;
       return f.call(this);
     };
   }
 

--- a/services/sync/tests/unit/test_errorhandler_1.js
+++ b/services/sync/tests/unit/test_errorhandler_1.js
@@ -14,16 +14,17 @@ Cu.import("resource://gre/modules/FileUt
 Cu.import("resource://gre/modules/PromiseUtils.jsm");
 
 var fakeServer = new SyncServer();
 fakeServer.start();
 
 do_register_cleanup(function() {
   return new Promise(resolve => {
     fakeServer.stop(resolve);
+    Svc.Prefs.resetBranch("");
   });
 });
 
 var fakeServerUrl = "http://localhost:" + fakeServer.port;
 
 const logsdir = FileUtils.getDir("ProfD", ["weave", "logs"], true);
 
 const PROLONGED_ERROR_DURATION =
@@ -59,16 +60,18 @@ function run_test() {
 function clean() {
   Service.startOver();
   Status.resetSync();
   Status.resetBackoff();
   errorHandler.didReportProlongedError = false;
 }
 
 add_task(async function test_401_logout() {
+  enableValidationPrefs();
+
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   await sync_and_validate_telem();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
 
@@ -102,16 +105,18 @@ add_task(async function test_401_logout(
   _("Starting first sync.");
   let ping = await sync_and_validate_telem(true);
   deepEqual(ping.failureReason, { name: "httperror", code: 401 });
   _("First sync done.");
   await deferred.promise;
 });
 
 add_task(async function test_credentials_changed_logout() {
+  enableValidationPrefs();
+
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   await sync_and_validate_telem();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
 
@@ -355,16 +360,18 @@ add_task(function test_shouldReportLogin
   do_check_true(errorHandler.shouldReportError());
   // But any other status with a missing clusterURL is treated as a mid-sync
   // 401 (ie, should be treated as a node reassignment)
   Status.login = LOGIN_SUCCEEDED;
   do_check_false(errorHandler.shouldReportError());
 });
 
 add_task(async function test_login_syncAndReportErrors_non_network_error() {
+  enableValidationPrefs();
+
   // Test non-network errors are reported
   // when calling syncAndReportErrors
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
   Service.identity.resetSyncKeyBundle();
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
@@ -373,16 +380,18 @@ add_task(async function test_login_syncA
   await promiseObserved;
   do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_syncAndReportErrors_non_network_error() {
+  enableValidationPrefs();
+
   // Test non-network errors are reported
   // when calling syncAndReportErrors
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
@@ -404,16 +413,18 @@ add_task(async function test_sync_syncAn
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   // If we clean this tick, telemetry won't get the right error
   await promiseNextTick();
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_login_syncAndReportErrors_prolonged_non_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, non-network errors are
   // reported when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
   Service.identity.resetSyncKeyBundle();
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
@@ -422,16 +433,18 @@ add_task(async function test_login_syncA
   await promiseObserved;
   do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_syncAndReportErrors_prolonged_non_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, non-network errors are
   // reported when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
@@ -453,16 +466,18 @@ add_task(async function test_sync_syncAn
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   // If we clean this tick, telemetry won't get the right error
   await promiseNextTick();
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_login_syncAndReportErrors_network_error() {
+  enableValidationPrefs();
+
   // Test network errors are reported when calling syncAndReportErrors.
   await configureIdentity({username: "broken.wipe"});
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   errorHandler.syncAndReportErrors();
@@ -470,16 +485,18 @@ add_task(async function test_login_syncA
 
   do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
 
   clean();
 });
 
 
 add_test(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;
@@ -487,16 +504,18 @@ add_test(function test_sync_syncAndRepor
     run_next_test();
   });
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   errorHandler.syncAndReportErrors();
 });
 
 add_task(async function test_login_syncAndReportErrors_prolonged_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, network errors are reported
   // when calling syncAndReportErrors.
   await configureIdentity({username: "johndoe"});
 
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
@@ -504,16 +523,18 @@ add_task(async function test_login_syncA
   errorHandler.syncAndReportErrors();
   await promiseObserved;
   do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
 
   clean();
 });
 
 add_test(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);
 
@@ -522,16 +543,18 @@ add_test(function test_sync_syncAndRepor
     run_next_test();
   });
 
   setLastSync(PROLONGED_ERROR_DURATION);
   errorHandler.syncAndReportErrors();
 });
 
 add_task(async function test_login_prolonged_non_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, non-network errors are reported
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
   Service.identity.resetSyncKeyBundle();
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(PROLONGED_ERROR_DURATION);
@@ -540,16 +563,18 @@ add_task(async function test_login_prolo
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_prolonged_non_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, non-network errors are reported
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
@@ -569,32 +594,36 @@ add_task(async function test_sync_prolon
   await promiseObserved;
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_login_prolonged_network_error() {
+  enableValidationPrefs();
+
   // Test prolonged, network errors are reported
   await configureIdentity({username: "johndoe"});
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(PROLONGED_ERROR_DURATION);
   Service.sync();
   await promiseObserved;
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
 });
 
 add_test(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);
 
@@ -603,16 +632,18 @@ add_test(function test_sync_prolonged_ne
     run_next_test();
   });
 
   setLastSync(PROLONGED_ERROR_DURATION);
   Service.sync();
 });
 
 add_task(async function test_login_non_network_error() {
+  enableValidationPrefs();
+
   // Test non-network errors are reported
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
   Service.identity.resetSyncKeyBundle();
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
@@ -621,16 +652,18 @@ add_task(async function test_login_non_n
   do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_non_network_error() {
+  enableValidationPrefs();
+
   // Test non-network errors are reported
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
@@ -645,16 +678,18 @@ add_task(async function test_sync_non_ne
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_login_network_error() {
+  enableValidationPrefs();
+
   await configureIdentity({username: "johndoe"});
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:clear-error");
   // Test network errors are not reported.
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   Service.sync();
@@ -662,16 +697,18 @@ add_task(async function test_login_netwo
   do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
   do_check_false(errorHandler.didReportProlongedError);
 
   Services.io.offline = false;
   clean();
 });
 
 add_test(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);
 
@@ -680,16 +717,18 @@ add_test(function test_sync_network_erro
     run_next_test();
   });
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   Service.sync();
 });
 
 add_task(async function test_sync_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 503,
@@ -714,16 +753,18 @@ add_task(async function test_sync_server
   do_check_eq(Status.sync, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 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();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -752,16 +793,18 @@ add_task(async function test_info_collec
   do_check_false(errorHandler.didReportProlongedError);
 
   Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
   clean();
   await promiseStopServer(server);
 });
 
 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();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {

--- a/services/sync/tests/unit/test_errorhandler_2.js
+++ b/services/sync/tests/unit/test_errorhandler_2.js
@@ -59,16 +59,18 @@ function run_test() {
 function clean() {
   Service.startOver();
   Status.resetSync();
   Status.resetBackoff();
   errorHandler.didReportProlongedError = false;
 }
 
 add_task(async function test_crypto_keys_login_server_maintenance_error() {
+  enableValidationPrefs();
+
   Status.resetSync();
   // Test crypto/keys server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
 
   // Force re-download of keys
@@ -101,16 +103,18 @@ add_task(async function test_crypto_keys
   do_check_false(errorHandler.didReportProlongedError);
 
   Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 503,
@@ -131,16 +135,18 @@ add_task(async function test_sync_prolon
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   await promiseStopServer(server);
   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();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -163,16 +169,18 @@ add_task(async function test_info_collec
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_meta_global_login_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test meta/global prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -195,16 +203,18 @@ add_task(async function test_meta_global
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_download_crypto_keys_login_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
 
@@ -228,16 +238,18 @@ add_task(async function test_download_cr
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_upload_crypto_keys_login_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -260,16 +272,18 @@ add_task(async function test_upload_cryp
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipeServer_login_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping the server.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;
@@ -293,16 +307,18 @@ add_task(async function test_wipeServer_
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipeRemote_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping all remote devices.
   let server = EHTestsCommon.sync_httpd_setup();
 
   server.registerPathHandler("/1.1/broken.wipe/storage/catapult", EHTestsCommon.service_unavailable);
   await configureIdentity({username: "broken.wipe"}, server);
   EHTestsCommon.generateAndUploadKeys();
 
@@ -333,16 +349,18 @@ add_task(async function test_wipeRemote_
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
   do_check_true(errorHandler.didReportProlongedError);
   await promiseStopServer(server);
   clean();
 });
 
 add_task(async function test_sync_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
@@ -361,16 +379,18 @@ add_task(async function test_sync_syncAn
   do_check_eq(Status.sync, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_info_collections_login_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test info/collections server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
@@ -394,16 +414,18 @@ add_task(async function test_info_collec
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_meta_global_login_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test meta/global server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
@@ -427,16 +449,18 @@ add_task(async function test_meta_global
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_download_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
@@ -462,16 +486,18 @@ add_task(async function test_download_cr
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
@@ -495,16 +521,18 @@ add_task(async function test_upload_cryp
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipeServer_login_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;
@@ -528,16 +556,18 @@ add_task(async function test_wipeServer_
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipeRemote_syncAndReportErrors_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping all remote devices.
   let server = EHTestsCommon.sync_httpd_setup();
 
   await configureIdentity({username: "broken.wipe"}, server);
   EHTestsCommon.generateAndUploadKeys();
 
   let engine = engineManager.get("catapult");
@@ -567,16 +597,18 @@ add_task(async function test_wipeRemote_
   do_check_eq(Svc.Prefs.get("firstSync"), "wipeRemote");
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_sync_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test prolonged server maintenance errors are
   // reported when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
@@ -597,16 +629,18 @@ add_task(async function test_sync_syncAn
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_info_collections_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test info/collections server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
@@ -632,16 +666,18 @@ add_task(async function test_info_collec
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_meta_global_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test meta/global server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
@@ -667,16 +703,18 @@ add_task(async function test_meta_global
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_download_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
@@ -704,16 +742,18 @@ add_task(async function test_download_cr
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
@@ -739,16 +779,18 @@ add_task(async function test_upload_cryp
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
 add_task(async function test_wipeServer_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+  enableValidationPrefs();
+
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;
@@ -774,16 +816,18 @@ add_task(async function test_wipeServer_
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   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");
   engine.enabled = true;
   engine.sync = function sync() {
     Svc.Obs.notify("weave:engine:sync:error", ENGINE_UNKNOWN_FAIL, "catapult");
   };
 
@@ -830,16 +874,18 @@ let engine = engineManager.get("catapult
   let ping = await sync_and_validate_telem(true);
   deepEqual(ping.status.service, SYNC_FAILED_PARTIAL);
   deepEqual(ping.engines.find(e => e.status).status, ENGINE_UNKNOWN_FAIL);
 
   await deferred.promise;
 });
 
 add_test(function test_logs_on_sync_error_despite_shouldReportError() {
+  enableValidationPrefs();
+
   _("Ensure that an error is still logged when weave:service:sync:error " +
     "is notified, despite shouldReportError returning false.");
 
   let log = Log.repository.getLogger("Sync.ErrorHandler");
   Svc.Prefs.set("log.appender.file.logOnError", true);
   log.info("TESTING");
 
   // Ensure that we report no error.
@@ -857,16 +903,18 @@ add_test(function test_logs_on_sync_erro
 
     clean();
     run_next_test();
   });
   Svc.Obs.notify("weave:service:sync:error", {});
 });
 
 add_test(function test_logs_on_login_error_despite_shouldReportError() {
+  enableValidationPrefs();
+
   _("Ensure that an error is still logged when weave:service:login:error " +
     "is notified, despite shouldReportError returning false.");
 
   let log = Log.repository.getLogger("Sync.ErrorHandler");
   Svc.Prefs.set("log.appender.file.logOnError", true);
   log.info("TESTING");
 
   // Ensure that we report no error.
@@ -886,16 +934,18 @@ add_test(function test_logs_on_login_err
     run_next_test();
   });
   Svc.Obs.notify("weave:service:login:error", {});
 });
 
 // This test should be the last one since it monkeypatches the engine object
 // and we should only have one engine object throughout the file (bug 629664).
 add_task(async function test_engine_applyFailed() {
+  enableValidationPrefs();
+
   let server = EHTestsCommon.sync_httpd_setup();
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   delete engine.exception;
   engine.sync = function sync() {
     Svc.Obs.notify("weave:engine:sync:applied", {newFailed:1}, "catapult");
   };

--- a/services/sync/tests/unit/test_errorhandler_sync_checkServerError.js
+++ b/services/sync/tests/unit/test_errorhandler_sync_checkServerError.js
@@ -62,16 +62,18 @@ function generateAndUploadKeys(server) {
   let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
   serverKeys.encrypt(Service.identity.syncKeyBundle);
   let res = Service.resource(server.baseURI + "/1.1/johndoe/storage/crypto/keys");
   return serverKeys.upload(res).success;
 }
 
 
 add_task(async function test_backoff500() {
+  enableValidationPrefs();
+
   _("Test: HTTP 500 sets backoff status.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 500};
 
@@ -89,16 +91,18 @@ add_task(async function test_backoff500(
   } finally {
     Status.resetBackoff();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
 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();
   await setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 503,
@@ -125,16 +129,18 @@ add_task(async function test_backoff503(
     Status.resetBackoff();
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
 add_task(async function test_overQuota() {
+  enableValidationPrefs();
+
   _("Test: HTTP 400 with body error code 14 means over quota.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 400,
                       toString() {
@@ -154,16 +160,18 @@ add_task(async function test_overQuota()
   } finally {
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
 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();
   await setUp(server);
   await promiseStopServer(server);
   // Provoke connection refused.
   Service.clusterURL = "http://localhost:12345/";
 
   try {
@@ -176,16 +184,18 @@ add_task(async function test_service_net
     do_check_eq(Status.service, SYNC_FAILED);
   } finally {
     Status.resetSync();
     Service.startOver();
   }
 });
 
 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();
   await setUp(server);
 
   await promiseStopServer(server);
   Services.io.offline = true;
   Services.prefs.setBoolPref("network.dns.offline-localhost", false);
 
@@ -201,16 +211,18 @@ add_task(async function test_service_off
     Status.resetSync();
     Service.startOver();
   }
   Services.io.offline = false;
   Services.prefs.clearUserPref("network.dns.offline-localhost");
 });
 
 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();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = Components.Exception("NS_ERROR_UNKNOWN_HOST",
                                           Cr.NS_ERROR_UNKNOWN_HOST);
@@ -228,16 +240,18 @@ add_task(async function test_engine_netw
   } finally {
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
 add_task(async function test_resource_timeout() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   // Resource throws this when it encounters a timeout.
   engine.exception = Components.Exception("Aborting due to channel inactivity.",
                                           Cr.NS_ERROR_NET_TIMEOUT);

--- a/services/sync/tests/unit/test_fxa_node_reassignment.js
+++ b/services/sync/tests/unit/test_fxa_node_reassignment.js
@@ -171,16 +171,18 @@ async function syncAndExpectNodeReassign
   }
   await deferred.promise;
 }
 
 // Check that when we sync we don't request a new token by default - our
 // test setup has configured the client with a valid token, and that token
 // should be used to form the cluster URL.
 add_task(async function test_single_token_fetch() {
+  enableValidationPrefs();
+
   _("Test a normal sync only fetches 1 token");
 
   let numTokenFetches = 0;
 
   function afterTokenFetch() {
     numTokenFetches++;
   }
 
@@ -196,20 +198,23 @@ add_task(async function test_single_toke
   do_check_false(Service.isLoggedIn, "not already logged in");
   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 promiseStopServer(server);
 });
 
 add_task(async function test_momentary_401_engine() {
+  enableValidationPrefs();
+
   _("Test a failure for engine URLs that's resolved by reassignment.");
   let server = await prepareServer();
   let john   = server.user("johndoe");
 
   _("Enabling the Rotary engine.");
   let { engine, tracker } = registerRotaryEngine();
 
   // We need the server to be correctly set up prior to experimenting. Do this
@@ -254,16 +259,18 @@ add_task(async function test_momentary_4
                                       Service.storageURL + "rotary");
 
   tracker.clearChangedIDs();
   Service.engineManager.unregister(engine);
 });
 
 // This test ends up being a failing info fetch *after we're already logged in*.
 add_task(async function test_momentary_401_info_collections_loggedin() {
+  enableValidationPrefs();
+
   _("Test a failure for info/collections after login that's resolved by reassignment.");
   let server = await prepareServer();
 
   _("First sync to prepare server contents.");
   Service.sync();
 
   _("Arrange for info/collections to return a 401.");
   let oldHandler = server.toplevelHandlers.info;
@@ -282,16 +289,18 @@ add_task(async function test_momentary_4
                                       "weave:service:sync:finish",
                                       Service.infoURL);
 });
 
 // This test ends up being a failing info fetch *before we're logged in*.
 // In this case we expect to recover during the login phase - so the first
 // sync succeeds.
 add_task(async function test_momentary_401_info_collections_loggedout() {
+  enableValidationPrefs();
+
   _("Test a failure for info/collections before login that's resolved by reassignment.");
 
   let oldHandler;
   let sawTokenFetch = false;
 
   function afterTokenFetch() {
     // After a single token fetch, we undo our evil handleReassign hack, so
     // the next /info request returns the collection instead of a 401
@@ -314,16 +323,18 @@ add_task(async function test_momentary_4
   do_check_true(sawTokenFetch, "a new token was fetched by this test.")
   // and we are done.
   Service.startOver();
   await promiseStopServer(server);
 });
 
 // This test ends up being a failing meta/global fetch *after we're already logged in*.
 add_task(async function test_momentary_401_storage_loggedin() {
+  enableValidationPrefs();
+
   _("Test a failure for any storage URL after login that's resolved by" +
     "reassignment.");
   let server = await prepareServer();
 
   _("First sync to prepare server contents.");
   Service.sync();
 
   _("Arrange for meta/global to return a 401.");
@@ -341,16 +352,18 @@ add_task(async function test_momentary_4
                                       "weave:service:sync:error",
                                       undo,
                                       "weave:service:sync:finish",
                                       Service.storageURL + "meta/global");
 });
 
 // This test ends up being a failing meta/global fetch *before we've logged in*.
 add_task(async function test_momentary_401_storage_loggedout() {
+  enableValidationPrefs();
+
   _("Test a failure for any storage URL before login, not just engine parts. " +
     "Resolved by reassignment.");
   let server = await prepareServer();
 
   // Return a 401 for all storage requests.
   let oldHandler = server.toplevelHandlers.storage;
   server.toplevelHandlers.storage = handleReassign;
 

--- a/services/sync/tests/unit/test_hmac_error.js
+++ b/services/sync/tests/unit/test_hmac_error.js
@@ -13,16 +13,18 @@ var hmacErrorCount = 0;
   let hHE = Service.handleHMACEvent;
   Service.handleHMACEvent = function() {
     hmacErrorCount++;
     return hHE.call(Service);
   };
 })();
 
 function shared_setup() {
+  enableValidationPrefs();
+
   hmacErrorCount = 0;
 
   // Make sure RotaryEngine is the only one we sync.
   let { engine, tracker } = 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"};
   tracker.addChangedID("scotsman", 0);

--- a/services/sync/tests/unit/test_interval_triggers.js
+++ b/services/sync/tests/unit/test_interval_triggers.js
@@ -53,16 +53,18 @@ function run_test() {
 
   Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
   Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
 
   run_next_test();
 }
 
 add_task(async function test_successful_sync_adjustSyncInterval() {
+  enableValidationPrefs();
+
   _("Test successful sync calling adjustSyncInterval");
   let syncSuccesses = 0;
   function onSyncFinish() {
     _("Sync success.");
     syncSuccesses++;
   }
   Svc.Obs.add("weave:service:sync:finish", onSyncFinish);
 
@@ -152,16 +154,18 @@ add_task(async function test_successful_
   do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
 
   Svc.Obs.remove("weave:service:sync:finish", onSyncFinish);
   Service.startOver();
   await promiseStopServer(server);
 });
 
 add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
+  enableValidationPrefs();
+
   _("Test unsuccessful sync calling adjustSyncInterval");
 
   let syncFailures = 0;
   function onSyncError() {
     _("Sync error.");
     syncFailures++;
   }
   Svc.Obs.add("weave:service:sync:error", onSyncError);
@@ -258,16 +262,18 @@ add_task(async function test_unsuccessfu
   do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
 
   Service.startOver();
   Svc.Obs.remove("weave:service:sync:error", onSyncError);
   await promiseStopServer(server);
 });
 
 add_task(async function test_back_triggers_sync() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Single device: no sync triggered.
   scheduler.idle = true;
   scheduler.observe(null, "active", Svc.Prefs.get("scheduler.idleTime"));
   do_check_false(scheduler.idle);
 
@@ -287,16 +293,18 @@ add_task(async function test_back_trigge
   scheduler.setDefaults();
   clientsEngine.resetClient();
 
   Service.startOver();
   await promiseStopServer(server);
 });
 
 add_task(async function test_adjust_interval_on_sync_error() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   let syncFailures = 0;
   function onSyncError() {
     _("Sync error.");
     syncFailures++;
   }
@@ -318,16 +326,18 @@ add_task(async function test_adjust_inte
   do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
 
   Svc.Obs.remove("weave:service:sync:error", onSyncError);
   Service.startOver();
   await promiseStopServer(server);
 });
 
 add_task(async function test_bug671378_scenario() {
+  enableValidationPrefs();
+
   // Test scenario similar to bug 671378. This bug appeared when a score
   // update occurred that wasn't large enough to trigger a sync so
   // scheduleNextSync() was called without a time interval parameter,
   // setting nextSync to a non-zero value and preventing the timer from
   // being adjusted in the next call to scheduleNextSync().
   let server = sync_httpd_setup();
   await setUp(server);
 

--- a/services/sync/tests/unit/test_node_reassignment.js
+++ b/services/sync/tests/unit/test_node_reassignment.js
@@ -130,16 +130,18 @@ async function syncAndExpectNodeReassign
   request.get(function() {
     do_check_eq(request.response.status, 401);
     Utils.nextTick(onwards);
   });
   await deferred.promise;
 }
 
 add_task(async function test_momentary_401_engine() {
+  enableValidationPrefs();
+
   _("Test a failure for engine URLs that's resolved by reassignment.");
   let server = await prepareServer();
   let john   = server.user("johndoe");
 
   _("Enabling the Rotary engine.");
   let { engine, tracker } = registerRotaryEngine();
 
   // We need the server to be correctly set up prior to experimenting. Do this
@@ -184,16 +186,18 @@ add_task(async function test_momentary_4
                                       Service.storageURL + "rotary");
 
   tracker.clearChangedIDs();
   Service.engineManager.unregister(engine);
 });
 
 // This test ends up being a failing fetch *after we're already logged in*.
 add_task(async function test_momentary_401_info_collections() {
+  enableValidationPrefs();
+
   _("Test a failure for info/collections that's resolved by reassignment.");
   let server = await prepareServer();
 
   _("First sync to prepare server contents.");
   Service.sync();
 
   // Return a 401 for info requests, particularly info/collections.
   let oldHandler = server.toplevelHandlers.info;
@@ -207,16 +211,18 @@ add_task(async function test_momentary_4
   await syncAndExpectNodeReassignment(server,
                                       "weave:service:sync:error",
                                       undo,
                                       "weave:service:sync:finish",
                                       Service.infoURL);
 });
 
 add_task(async function test_momentary_401_storage_loggedin() {
+  enableValidationPrefs();
+
   _("Test a failure for any storage URL, not just engine parts. " +
     "Resolved by reassignment.");
   let server = await prepareServer();
 
   _("Performing initial sync to ensure we are logged in.")
   Service.sync();
 
   // Return a 401 for all storage requests.
@@ -232,16 +238,18 @@ add_task(async function test_momentary_4
   await syncAndExpectNodeReassignment(server,
                                       "weave:service:sync:error",
                                       undo,
                                       "weave:service:sync:finish",
                                       Service.storageURL + "meta/global");
 });
 
 add_task(async function test_momentary_401_storage_loggedout() {
+  enableValidationPrefs();
+
   _("Test a failure for any storage URL, not just engine parts. " +
     "Resolved by reassignment.");
   let server = await prepareServer();
 
   // Return a 401 for all storage requests.
   let oldHandler = server.toplevelHandlers.storage;
   server.toplevelHandlers.storage = handleReassign;
 
@@ -254,16 +262,18 @@ add_task(async function test_momentary_4
   await syncAndExpectNodeReassignment(server,
                                       "weave:service:login:error",
                                       undo,
                                       "weave:service:sync:finish",
                                       Service.storageURL + "meta/global");
 });
 
 add_task(async function test_loop_avoidance_storage() {
+  enableValidationPrefs();
+
   _("Test that a repeated failure doesn't result in a sync loop " +
     "if node reassignment cannot resolve the failure.");
 
   let server = await prepareServer();
 
   // Return a 401 for all storage requests.
   let oldHandler = server.toplevelHandlers.storage;
   server.toplevelHandlers.storage = handleReassign;
@@ -353,16 +363,18 @@ add_task(async function test_loop_avoida
   Svc.Obs.add(firstNotification, onFirstSync);
 
   now = Date.now();
   Service.sync();
   await deferred.promise;
 });
 
 add_task(async function test_loop_avoidance_engine() {
+  enableValidationPrefs();
+
   _("Test that a repeated 401 in an engine doesn't result in a sync loop " +
     "if node reassignment cannot resolve the failure.");
   let server = await prepareServer();
   let john   = server.user("johndoe");
 
   _("Enabling the Rotary engine.");
   let { engine, tracker } = registerRotaryEngine();
   let deferred = PromiseUtils.defer();

--- a/services/sync/tests/unit/test_score_triggers.js
+++ b/services/sync/tests/unit/test_score_triggers.js
@@ -47,16 +47,17 @@ function run_test() {
   initTestLogging("Trace");
 
   Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
 
   run_next_test();
 }
 
 add_test(function test_tracker_score_updated() {
+  enableValidationPrefs();
   let { engine, tracker } = registerRotaryEngine();
 
   let scoreUpdated = 0;
 
   function onScoreUpdated() {
     scoreUpdated++;
   }
 
@@ -86,46 +87,54 @@ add_task(async function test_sync_trigge
 
   Service.scheduler.syncThreshold = MULTI_DEVICE_THRESHOLD;
 
 
   do_check_eq(Status.login, LOGIN_SUCCEEDED);
   tracker.score += SCORE_INCREMENT_XLARGE;
 
   await promiseOneObserver("weave:service:sync:finish");
+
+  Service.startOver();
   await promiseStopServer(server);
 
   tracker.clearChangedIDs();
   Service.engineManager.unregister(engine);
 });
 
 add_task(async function test_clients_engine_sync_triggered() {
+  enableValidationPrefs();
+
   _("Ensure that client engine score changes trigger a sync.");
 
   // The clients engine is not registered like other engines. Therefore,
   // it needs special treatment throughout the code. Here, we verify the
   // global score tracker gives it that treatment. See bug 676042 for more.
 
   let server = sync_httpd_setup();
   let { engine, tracker } = await setUp(server);
   Service.login();
 
   Service.scheduler.syncThreshold = MULTI_DEVICE_THRESHOLD;
   do_check_eq(Status.login, LOGIN_SUCCEEDED);
   Service.clientsEngine._tracker.score += SCORE_INCREMENT_XLARGE;
 
   await promiseOneObserver("weave:service:sync:finish");
   _("Sync due to clients engine change completed.");
+
+  Service.startOver();
   await promiseStopServer(server);
 
   tracker.clearChangedIDs();
   Service.engineManager.unregister(engine);
 });
 
 add_task(async function test_incorrect_credentials_sync_not_triggered() {
+  enableValidationPrefs();
+
   _("Ensure that score changes don't trigger a sync if Status.login != LOGIN_SUCCEEDED.");
   let server = sync_httpd_setup();
   let { engine, tracker } = await setUp(server);
 
   // Ensure we don't actually try to sync.
   function onSyncStart() {
     do_throw("Should not get here!");
   }

--- a/services/sync/tests/unit/test_service_detect_upgrade.js
+++ b/services/sync/tests/unit/test_service_detect_upgrade.js
@@ -9,16 +9,18 @@ Cu.import("resource://services-sync/engi
 Cu.import("resource://services-sync/record.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
 
 Service.engineManager.register(TabEngine);
 
 add_task(async function v4_upgrade() {
+  enableValidationPrefs();
+
   let clients = new ServerCollection();
   let meta_global = new ServerWBO("global");
 
   // Tracking info/collections.
   let collectionsHelper = track_collections_helper();
   let upd = collectionsHelper.with_updated_collection;
   let collections = collectionsHelper.collections;
 
@@ -180,16 +182,18 @@ add_task(async function v4_upgrade() {
 
   } finally {
     Svc.Prefs.resetBranch("");
     await promiseStopServer(server);
   }
 });
 
 add_task(async function v5_upgrade() {
+  enableValidationPrefs();
+
   // Tracking info/collections.
   let collectionsHelper = track_collections_helper();
   let upd = collectionsHelper.with_updated_collection;
 
   let keysWBO = new ServerWBO("keys");
   let bulkWBO = new ServerWBO("bulk");
   let clients = new ServerCollection();
   let meta_global = new ServerWBO("global");

--- a/services/sync/tests/unit/test_service_login.js
+++ b/services/sync/tests/unit/test_service_login.js
@@ -58,16 +58,18 @@ function setup() {
     "/1.1/janedoe/storage/crypto/keys": janeU("crypto", new ServerWBO("keys").handler()),
     "/1.1/janedoe/storage/meta/global": janeU("meta", new ServerWBO("global").handler())
   });
 
   return server;
 }
 
 add_task(async function test_login_logout() {
+  enableValidationPrefs();
+
   let server = setup();
 
   try {
     _("Force the initial state.");
     Service.status.service = STATUS_OK;
     do_check_eq(Service.status.service, STATUS_OK);
 
     _("Try logging in. It won't work because we're not configured yet.");
@@ -93,16 +95,18 @@ add_task(async function test_login_logou
 
   } finally {
     Svc.Prefs.resetBranch("");
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_login_on_sync() {
+  enableValidationPrefs();
+
   let server = setup();
   await configureIdentity({ username: "johndoe" }, server);
 
   try {
     _("Sync calls login.");
     let oldLogin = Service.login;
     let loginCalled = false;
     Service.login = function() {

--- a/services/sync/tests/unit/test_service_sync_remoteSetup.js
+++ b/services/sync/tests/unit/test_service_sync_remoteSetup.js
@@ -5,16 +5,18 @@ Cu.import("resource://gre/modules/Log.js
 Cu.import("resource://services-sync/constants.js");
 Cu.import("resource://services-sync/keys.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/fakeservices.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
 
 add_task(async function run_test() {
+  enableValidationPrefs();
+
   validate_all_future_pings();
   Log.repository.rootLogger.addAppender(new Log.DumpAppender());
 
   let clients = new ServerCollection();
   let meta_global = new ServerWBO("global");
 
   let collectionsHelper = track_collections_helper();
   let upd = collectionsHelper.with_updated_collection;

--- a/services/sync/tests/unit/test_service_sync_specified.js
+++ b/services/sync/tests/unit/test_service_sync_specified.js
@@ -79,77 +79,87 @@ function run_test() {
   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();
 }
 
 add_task(async function test_noEngines() {
+  enableValidationPrefs();
+
   _("Test: An empty array of engines to sync does nothing.");
   let server = await setUp();
 
   try {
     _("Sync with no engines specified.");
     Service.sync([]);
     deepEqual(syncedEngines, [], "no engines were synced");
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_oneEngine() {
+  enableValidationPrefs();
+
   _("Test: Only one engine is synced.");
   let server = await setUp();
 
   try {
 
     _("Sync with 1 engine specified.");
     Service.sync(["steam"]);
     deepEqual(syncedEngines, ["steam"])
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_bothEnginesSpecified() {
+  enableValidationPrefs();
+
   _("Test: All engines are synced when specified in the correct order (1).");
   let server = await setUp();
 
   try {
     _("Sync with both engines specified.");
     Service.sync(["steam", "stirling"]);
     deepEqual(syncedEngines, ["steam", "stirling"])
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_bothEnginesSpecified() {
+  enableValidationPrefs();
+
   _("Test: All engines are synced when specified in the correct order (2).");
   let server = await setUp();
 
   try {
     _("Sync with both engines specified.");
     Service.sync(["stirling", "steam"]);
     deepEqual(syncedEngines, ["stirling", "steam"])
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_bothEnginesDefault() {
+  enableValidationPrefs();
+
   _("Test: All engines are synced when nothing is specified.");
   let server = await setUp();
 
   try {
     Service.sync();
     deepEqual(syncedEngines, ["steam", "stirling"])
 
   } finally {

--- a/services/sync/tests/unit/test_service_sync_updateEnabledEngines.js
+++ b/services/sync/tests/unit/test_service_sync_updateEnabledEngines.js
@@ -86,16 +86,18 @@ function run_test() {
   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();
 }
 
 add_task(async function test_newAccount() {
+  enableValidationPrefs();
+
   _("Test: New account does not disable locally enabled engines.");
   let engine = Service.engineManager.get("steam");
   let server = sync_httpd_setup({
     "/1.1/johndoe/storage/meta/global": new ServerWBO("global", {}).handler(),
     "/1.1/johndoe/storage/steam": new ServerWBO("steam", {}).handler()
   });
   await setUp(server);
 
@@ -112,16 +114,18 @@ add_task(async function test_newAccount(
     do_check_true(engine.enabled);
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_enabledLocally() {
+  enableValidationPrefs();
+
   _("Test: Engine is disabled on remote clients and enabled locally");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {syncID: Service.syncID,
                                          storageVersion: STORAGE_VERSION,
                                          engines: {}});
   let server = sync_httpd_setup({
     "/1.1/johndoe/storage/meta/global": metaWBO.handler(),
@@ -143,16 +147,18 @@ add_task(async function test_enabledLoca
     do_check_true(engine.enabled);
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_disabledLocally() {
+  enableValidationPrefs();
+
   _("Test: Engine is enabled on remote clients and disabled locally");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {
     syncID: Service.syncID,
     storageVersion: STORAGE_VERSION,
     engines: {steam: {syncID: engine.syncID,
                       version: engine.version}}
@@ -185,16 +191,18 @@ add_task(async function test_disabledLoc
     do_check_false(engine.enabled);
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_disabledLocally_wipe503() {
+  enableValidationPrefs();
+
   _("Test: Engine is enabled on remote clients and disabled locally");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {
     syncID: Service.syncID,
     storageVersion: STORAGE_VERSION,
     engines: {steam: {syncID: engine.syncID,
                       version: engine.version}}
@@ -226,16 +234,18 @@ add_task(async function test_disabledLoc
   await promiseObserved;
   do_check_eq(Service.status.sync, SERVER_MAINTENANCE);
 
   Service.startOver();
   await promiseStopServer(server);
 });
 
 add_task(async function test_enabledRemotely() {
+  enableValidationPrefs();
+
   _("Test: Engine is disabled locally and enabled on a remote client");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {
     syncID: Service.syncID,
     storageVersion: STORAGE_VERSION,
     engines: {steam: {syncID: engine.syncID,
                       version: engine.version}}
@@ -270,16 +280,18 @@ add_task(async function test_enabledRemo
     do_check_eq(metaWBO.data.engines.steam.syncID, engine.syncID);
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_disabledRemotelyTwoClients() {
+  enableValidationPrefs();
+
   _("Test: Engine is enabled locally and disabled on a remote client... with two clients.");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {syncID: Service.syncID,
                                          storageVersion: STORAGE_VERSION,
                                          engines: {}});
   let server = sync_httpd_setup({
     "/1.1/johndoe/storage/meta/global":
@@ -314,16 +326,18 @@ add_task(async function test_disabledRem
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_disabledRemotely() {
+  enableValidationPrefs();
+
   _("Test: Engine is enabled locally and disabled on a remote client");
   Service.syncID = "abcdefghij";
   let engine = Service.engineManager.get("steam");
   let metaWBO = new ServerWBO("global", {syncID: Service.syncID,
                                          storageVersion: STORAGE_VERSION,
                                          engines: {}});
   let server = sync_httpd_setup({
     "/1.1/johndoe/storage/meta/global": metaWBO.handler(),
@@ -345,16 +359,18 @@ add_task(async function test_disabledRem
 
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_dependentEnginesEnabledLocally() {
+  enableValidationPrefs();
+
   _("Test: Engine is disabled on remote clients and enabled locally");
   Service.syncID = "abcdefghij";
   let steamEngine = Service.engineManager.get("steam");
   let stirlingEngine = Service.engineManager.get("stirling");
   let metaWBO = new ServerWBO("global", {syncID: Service.syncID,
                                          storageVersion: STORAGE_VERSION,
                                          engines: {}});
   let server = sync_httpd_setup({
@@ -380,16 +396,18 @@ add_task(async function test_dependentEn
     do_check_true(stirlingEngine.enabled);
   } finally {
     Service.startOver();
     await promiseStopServer(server);
   }
 });
 
 add_task(async function test_dependentEnginesDisabledLocally() {
+  enableValidationPrefs();
+
   _("Test: Two dependent engines are enabled on remote clients and disabled locally");
   Service.syncID = "abcdefghij";
   let steamEngine = Service.engineManager.get("steam");
   let stirlingEngine = Service.engineManager.get("stirling");
   let metaWBO = new ServerWBO("global", {
     syncID: Service.syncID,
     storageVersion: STORAGE_VERSION,
     engines: {steam: {syncID: steamEngine.syncID,

--- a/services/sync/tests/unit/test_syncscheduler.js
+++ b/services/sync/tests/unit/test_syncscheduler.js
@@ -188,16 +188,18 @@ add_task(async function test_updateClien
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.numClients > 1);
   do_check_false(scheduler.idle);
 
   await cleanUpAndGo();
 });
 
 add_task(async function test_masterpassword_locked_retry_interval() {
+  enableValidationPrefs();
+
   _("Test Status.login = MASTER_PASSWORD_LOCKED results in reschedule at MASTER_PASSWORD interval");
   let loginFailed = false;
   Svc.Obs.add("weave:service:login:error", function onLoginError() {
     Svc.Obs.remove("weave:service:login:error", onLoginError);
     loginFailed = true;
   });
 
   let rescheduleInterval = false;
@@ -247,28 +249,32 @@ add_task(async function test_calculateBa
                                            Status.backoffInterval);
 
   do_check_eq(backoffInterval, MAXIMUM_BACKOFF_INTERVAL + 10);
 
   await cleanUpAndGo();
 });
 
 add_task(async function test_scheduleNextSync_nowOrPast() {
+  enableValidationPrefs();
+
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   // We're late for a sync...
   scheduler.scheduleNextSync(-1);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_scheduleNextSync_future_noBackoff() {
+  enableValidationPrefs();
+
   _("scheduleNextSync() uses the current syncInterval if no interval is provided.");
   // Test backoffInterval is 0 as expected.
   do_check_eq(Status.backoffInterval, 0);
 
   _("Test setting sync interval when nextSync == 0");
   scheduler.nextSync = 0;
   scheduler.scheduleNextSync();
 
@@ -308,16 +314,18 @@ add_task(async function test_scheduleNex
   scheduler.scheduleNextSync(1);
   do_check_true(scheduler.nextSync <= Date.now() + 1);
   do_check_eq(scheduler.syncTimer.delay, 1);
 
   await cleanUpAndGo();
 });
 
 add_task(async function test_scheduleNextSync_future_backoff() {
+  enableValidationPrefs();
+
  _("scheduleNextSync() will honour backoff in all scheduling requests.");
   // Let's take a backoff interval that's bigger than the default sync interval.
   const BACKOFF = 7337;
   Status.backoffInterval = scheduler.syncInterval + BACKOFF;
 
   _("Test setting sync interval when nextSync == 0");
   scheduler.nextSync = 0;
   scheduler.scheduleNextSync();
@@ -358,16 +366,18 @@ add_task(async function test_scheduleNex
   scheduler.scheduleNextSync(1);
   do_check_true(scheduler.nextSync <= Date.now() + Status.backoffInterval);
   do_check_eq(scheduler.syncTimer.delay, Status.backoffInterval);
 
   await cleanUpAndGo();
 });
 
 add_task(async function test_handleSyncError() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Force sync to fail.
   Svc.Prefs.set("firstSync", "notReady");
 
   _("Ensure expected initial environment.");
   do_check_eq(scheduler._syncErrors, 0);
@@ -421,16 +431,18 @@ add_task(async function test_handleSyncE
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
   Svc.Prefs.set("firstSync", "wipeRemote");
   scheduler.scheduleNextSync(-1);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_client_sync_finish_updateClientMode() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Confirm defaults.
   do_check_eq(scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.idle);
 
@@ -460,28 +472,32 @@ add_task(async function test_client_sync
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.numClients > 1);
   do_check_false(scheduler.idle);
 
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_autoconnect_nextSync_past() {
+  enableValidationPrefs();
+
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
   // nextSync will be 0 by default, so it's way in the past.
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   scheduler.delayedAutoConnect(0);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_autoconnect_nextSync_future() {
+  enableValidationPrefs();
+
   let previousSync = Date.now() + scheduler.syncInterval / 2;
   scheduler.nextSync = previousSync;
   // nextSync rounds to the nearest second.
   let expectedSync = scheduler.nextSync;
   let expectedInterval = expectedSync - Date.now() - 1000;
 
   // Ensure we don't actually try to sync (or log in for that matter).
   function onLoginStart() {
@@ -570,16 +586,18 @@ add_task(async function test_no_autoconn
 
   do_check_eq(Status.service, CLIENT_NOT_CONFIGURED);
   do_check_eq(Status.login, LOGIN_FAILED_NO_USERNAME);
 
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_autoconnectDelay_pref() {
+  enableValidationPrefs();
+
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
 
   Svc.Prefs.set("autoconnectDelay", 1);
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   Svc.Obs.notify("weave:service:ready");
@@ -685,16 +703,18 @@ add_task(async function test_back_deboun
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
 
   await promiseNamedTimer(IDLE_OBSERVER_BACK_DELAY * 1.5, {}, "timer");
   Svc.Obs.remove("weave:service:login:start", onLoginStart);
   await cleanUpAndGo();
 });
 
 add_task(async function test_no_sync_node() {
+  enableValidationPrefs();
+
   // Test when Status.sync == NO_SYNC_NODE_FOUND
   // it is not overwritten on sync:finish
   let server = sync_httpd_setup();
   await setUp(server);
 
   let oldfc = Service._clusterManager._findCluster;
   Service._clusterManager._findCluster = () => null;
   Service.clusterURL = "";
@@ -705,16 +725,18 @@ add_task(async function test_no_sync_nod
 
     await cleanUpAndGo(server);
   } finally {
     Service._clusterManager._findCluster = oldfc;
   }
 });
 
 add_task(async function test_sync_failed_partial_500s() {
+  enableValidationPrefs();
+
   _("Test a 5xx status calls handleSyncError.");
   scheduler._syncErrors = MAX_ERROR_COUNT_BEFORE_BACKOFF;
   let server = sync_httpd_setup();
 
   let engine = Service.engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 500};
 
@@ -732,16 +754,18 @@ add_task(async function test_sync_failed
   do_check_eq(scheduler._syncErrors, 4);
   do_check_true(scheduler.nextSync <= (Date.now() + maxInterval));
   do_check_true(scheduler.syncTimer.delay <= maxInterval);
 
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_sync_failed_partial_400s() {
+  enableValidationPrefs();
+
   _("Test a non-5xx status doesn't call handleSyncError.");
   scheduler._syncErrors = MAX_ERROR_COUNT_BEFORE_BACKOFF;
   let server = sync_httpd_setup();
 
   let engine = Service.engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 400};
 
@@ -764,16 +788,18 @@ add_task(async function test_sync_failed
   do_check_eq(scheduler._syncErrors, 0);
   do_check_true(scheduler.nextSync <= (Date.now() + scheduler.activeInterval));
   do_check_true(scheduler.syncTimer.delay <= scheduler.activeInterval);
 
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_sync_X_Weave_Backoff() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Use an odd value on purpose so that it doesn't happen to coincide with one
   // of the sync intervals.
   const BACKOFF = 7337;
 
   // Extend info/collections so that we can put it into server maintenance mode.
@@ -821,16 +847,18 @@ add_task(async function test_sync_X_Weav
   // Verify that the next sync is actually going to wait that long.
   do_check_true(scheduler.nextSync >= Date.now() + minimumExpectedDelay);
   do_check_true(scheduler.syncTimer.delay >= minimumExpectedDelay);
 
   await cleanUpAndGo(server);
 });
 
 add_task(async function test_sync_503_Retry_After() {
+  enableValidationPrefs();
+
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Use an odd value on purpose so that it doesn't happen to coincide with one
   // of the sync intervals.
   const BACKOFF = 7337;
 
   // Extend info/collections so that we can put it into server maintenance mode.

--- a/services/sync/tests/unit/test_telemetry.js
+++ b/services/sync/tests/unit/test_telemetry.js
@@ -66,16 +66,18 @@ async function cleanAndGo(engine, server
   Service.recordManager.clearCache();
   await promiseStopServer(server);
 }
 
 // Avoid addon manager complaining about not being initialized
 Service.engineManager.unregister("addons");
 
 add_task(async function test_basic() {
+  enableValidationPrefs();
+
   let helper = track_collections_helper();
   let upd = helper.with_updated_collection;
 
   let handlers = {
     "/1.1/johndoe/info/collections": helper.handler,
     "/1.1/johndoe/storage/crypto/keys": upd("crypto", new ServerWBO("keys").handler()),
     "/1.1/johndoe/storage/meta/global": upd("meta", new ServerWBO("global").handler())
   };
@@ -86,16 +88,17 @@ add_task(async function test_basic() {
     handlers["/1.1/johndoe/storage/" + coll] = upd(coll, new ServerCollection({}, true).handler());
   }
 
   let server = httpd_setup(handlers);
   await configureIdentity({ username: "johndoe" }, server);
 
   await sync_and_validate_telem(true);
 
+  Svc.Prefs.resetBranch("");
   await promiseStopServer(server);
 });
 
 add_task(async function test_processIncoming_error() {
   let engine = new BookmarksEngine(Service);
   let store  = engine._store;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bookmarks: {version: engine.version,
@@ -325,16 +328,18 @@ add_task(async function test_sync_partia
 
   } finally {
     await cleanAndGo(engine, server);
     await engine.finalize();
   }
 });
 
 add_task(async function test_generic_engine_fail() {
+  enableValidationPrefs();
+
   Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {steam: {version: engine.version,
                                       syncID: engine.syncID}}}},
     steam: {}
   });
@@ -353,16 +358,18 @@ add_task(async function test_generic_eng
     });
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_engine_fail_ioerror() {
+  enableValidationPrefs();
+
   Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {steam: {version: engine.version,
                                       syncID: engine.syncID}}}},
     steam: {}
   });
@@ -390,16 +397,18 @@ add_task(async function test_engine_fail
     ok(failureReason.error.includes("[profileDir]"), failureReason.error);
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_initial_sync_engines() {
+  enableValidationPrefs();
+
   Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let engines = {};
   // These are the only ones who actually have things to sync at startup.
   let engineNames = ["clients", "bookmarks", "prefs", "tabs"];
   let conf = { meta: { global: { engines } } };
   for (let e of engineNames) {
@@ -429,16 +438,18 @@ add_task(async function test_initial_syn
     }
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_nserror() {
+  enableValidationPrefs();
+
   Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {steam: {version: engine.version,
                                       syncID: engine.syncID}}}},
     steam: {}
   });
@@ -459,16 +470,18 @@ add_task(async function test_nserror() {
     });
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_discarding() {
+  enableValidationPrefs();
+
   let helper = track_collections_helper();
   let upd = helper.with_updated_collection;
   let telem = get_sync_test_telemetry();
   telem.maxPayloadCount = 2;
   telem.submissionInterval = Infinity;
   let oldSubmit = telem.submit;
 
   let server;
@@ -504,16 +517,18 @@ add_task(async function test_discarding(
     telem.submit = oldSubmit;
     if (server) {
       await promiseStopServer(server);
     }
   }
 })
 
 add_task(async function test_no_foreign_engines_in_error_ping() {
+  enableValidationPrefs();
+
   Service.engineManager.register(BogusEngine);
   let engine = Service.engineManager.get("bogus");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bogus: {version: engine.version, syncID: engine.syncID}}}},
     steam: {}
   });
   engine._errToThrow = new Error("Oh no!");
@@ -524,16 +539,18 @@ add_task(async function test_no_foreign_
     ok(ping.engines.every(e => e.name !== "bogus"));
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_sql_error() {
+  enableValidationPrefs();
+
   Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {steam: {version: engine.version,
                                       syncID: engine.syncID}}}},
     steam: {}
   });
@@ -551,16 +568,18 @@ add_task(async function test_sql_error()
     deepEqual(enginePing.failureReason, { name: "sqlerror", code: 1 });
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_no_foreign_engines_in_success_ping() {
+  enableValidationPrefs();
+
   Service.engineManager.register(BogusEngine);
   let engine = Service.engineManager.get("bogus");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bogus: {version: engine.version, syncID: engine.syncID}}}},
     steam: {}
   });
 
@@ -570,16 +589,18 @@ add_task(async function test_no_foreign_
     ok(ping.engines.every(e => e.name !== "bogus"));
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_events() {
+  enableValidationPrefs();
+
   Service.engineManager.register(BogusEngine);
   let engine = Service.engineManager.get("bogus");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bogus: {version: engine.version, syncID: engine.syncID}}}},
     steam: {}
   });
 
@@ -614,16 +635,18 @@ add_task(async function test_events() {
     equal(value, null);
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_invalid_events() {
+  enableValidationPrefs();
+
   Service.engineManager.register(BogusEngine);
   let engine = Service.engineManager.get("bogus");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bogus: {version: engine.version, syncID: engine.syncID}}}},
     steam: {}
   });
 
@@ -658,16 +681,18 @@ add_task(async function test_invalid_eve
     await checkNotRecorded("object", "method", "value", badextra);
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
 add_task(async function test_no_ping_for_self_hosters() {
+  enableValidationPrefs();
+
   let telem = get_sync_test_telemetry();
   let oldSubmit = telem.submit;
 
   Service.engineManager.register(BogusEngine);
   let engine = Service.engineManager.get("bogus");
   engine.enabled = true;
   let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bogus: {version: engine.version, syncID: engine.syncID}}}},