tor-browser

test_glean.js (40452B)

---

/* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */

const { Service } = ChromeUtils.importESModule(
 "resource://services-sync/service.sys.mjs"
);
const { WBORecord } = ChromeUtils.importESModule(
 "resource://services-sync/record.sys.mjs"
);
const { RotaryEngine } = ChromeUtils.importESModule(
 "resource://testing-common/services/sync/rotaryengine.sys.mjs"
);
const { getFxAccountsSingleton } = ChromeUtils.importESModule(
 "resource://gre/modules/FxAccounts.sys.mjs"
);
const fxAccounts = getFxAccountsSingleton();

function SteamStore(engine) {
 Store.call(this, "Steam", engine);
}
Object.setPrototypeOf(SteamStore.prototype, Store.prototype);

function SteamTracker(name, engine) {
 LegacyTracker.call(this, name || "Steam", engine);
}
Object.setPrototypeOf(SteamTracker.prototype, LegacyTracker.prototype);

function SteamEngine(service) {
 SyncEngine.call(this, "steam", service);
}

SteamEngine.prototype = {
 _storeObj: SteamStore,
 _trackerObj: SteamTracker,
 _errToThrow: null,
 problemsToReport: null,
 async _sync() {
   if (this._errToThrow) {
     throw this._errToThrow;
   }
 },
 getValidator() {
   return new SteamValidator();
 },
};
Object.setPrototypeOf(SteamEngine.prototype, SyncEngine.prototype);

function BogusEngine(service) {
 SyncEngine.call(this, "bogus", service);
}

BogusEngine.prototype = Object.create(SteamEngine.prototype);

class SteamValidator {
 async canValidate() {
   return true;
 }

 async validate(engine) {
   return {
     problems: new SteamValidationProblemData(engine.problemsToReport),
     version: 1,
     duration: 0,
     recordCount: 0,
   };
 }
}

class SteamValidationProblemData {
 constructor(problemsToReport = []) {
   this.problemsToReport = problemsToReport;
 }

 getSummary() {
   return this.problemsToReport;
 }
}

async function cleanAndGo(engine, server) {
 await engine._tracker.clearChangedIDs();
 for (const pref of Svc.PrefBranch.getChildList("")) {
   Svc.PrefBranch.clearUserPref(pref);
 }
 syncTestLogging();
 Service.recordManager.clearCache();
 await promiseStopServer(server);
}

async function sync_engine(engine, errorRegex = undefined) {
 // Clear out status so failures from previous syncs won't show in the record.
 let { Status } = ChromeUtils.importESModule(
   "resource://services-sync/status.sys.mjs"
 );
 Status._engines = {};
 Status.partial = false;
 // Neuter the scheduler as it interacts badly with some of the tests - the
 // engine being synced usually isn't the registered engine, so we see
 // scored incremented and not removed, which schedules unexpected syncs.
 let oldObserve = Service.scheduler.observe;
 Service.scheduler.observe = () => {};
 try {
   Svc.Obs.notify("weave:service:sync:start");
   let caughtError;
   try {
     await engine.sync();
   } catch (e) {
     caughtError = e;
   }
   if (caughtError) {
     ok(
       errorRegex.test(JSON.stringify(caughtError)),
       "Engine sync error expected."
     );
     Svc.Obs.notify("weave:service:sync:error", caughtError);
   } else {
     ok(!errorRegex, "No engine sync error expected.");
     Svc.Obs.notify("weave:service:sync:finish");
   }
 } finally {
   Service.scheduler.observe = oldObserve;
 }
}

add_setup(async function () {
 // Avoid addon manager complaining about not being initialized
 await Service.engineManager.unregister("addons");
 await Service.engineManager.unregister("extension-storage");

 do_get_profile(); // FOG requires a profile dir.
 Services.fog.initializeFOG();

 // We're not using `wait_for_ping` which means we aren't implicitly calling
 // get_sync_test_telemetry() so often. So call it here for its side effects.
 let telem = get_sync_test_telemetry();
 // Unlike the telemetry tests, we actually want the Glean APIs to be called.
 // So pretend we're in production.
 telem.isProductionSyncUser = () => true;
});

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()
   ),
 };

 let collections = [
   "clients",
   "bookmarks",
   "forms",
   "history",
   "passwords",
   "prefs",
   "tabs",
 ];

 for (let coll of collections) {
   handlers["/1.1/johndoe/storage/" + coll] = upd(
     coll,
     new ServerCollection({}, true).handler()
   );
 }

 let server = httpd_setup(handlers);
 await configureIdentity({ username: "johndoe" }, server);

 // Test that a basic batch can make it.
 await GleanPings.sync.testSubmission(
   reason => {
     equal(reason, "schedule");
     Glean.syncs.syncs.testGetValue().forEach(assert_success_sync);
   },
   async () => {
     await Service.sync();
   }
 );

 for (const pref of Svc.PrefBranch.getChildList("")) {
   Svc.PrefBranch.clearUserPref(pref);
 }
 await promiseStopServer(server);
});

add_task(async function test_processIncoming_error() {
 let engine = Service.engineManager.get("bookmarks");
 await engine.initialize();
 let store = engine._store;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 let collection = server.user("foo").collection("bookmarks");
 try {
   // Create a bogus record that when synced down will provoke a
   // network error which in turn provokes an exception in _processIncoming.
   const BOGUS_GUID = "zzzzzzzzzzzz";
   let bogus_record = collection.insert(BOGUS_GUID, "I'm a bogus record!");
   bogus_record.get = function get() {
     throw new Error("Sync this!");
   };
   // Make it 10 minutes old so it will only be synced in the toFetch phase.
   bogus_record.modified = Date.now() / 1000 - 60 * 10;
   await engine.setLastSync(Date.now() / 1000 - 60);
   engine.toFetch = new SerializableSet([BOGUS_GUID]);

   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       deepEqual(sync.failureReason, { name: "httperror", code: 500 });
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.name, "bookmarks-buffered");
       deepEqual(e.failureReason, { name: "httperror", code: 500 });
     },
     async () => {
       await sync_engine(engine, /500 Internal Server Error/);
     }
   );
 } finally {
   await store.wipe();
   await cleanAndGo(engine, server);
 }
});

add_task(async function test_uploading() {
 // Clear out status, so failures from previous syncs won't show up in the
 // telemetry ping.
 let { Status } = ChromeUtils.importESModule(
   "resource://services-sync/status.sys.mjs"
 );
 Status._engines = {};
 Status.partial = false;

 let engine = Service.engineManager.get("bookmarks");
 await engine.initialize();
 let store = engine._store;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);

 let bmk = await PlacesUtils.bookmarks.insert({
   parentGuid: PlacesUtils.bookmarks.toolbarGuid,
   url: "http://getfirefox.com/",
   title: "Get Firefox!",
 });

 try {
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.name, "bookmarks-buffered");
       greater(e.outgoing[0].sent, 0);
       ok(!e.incoming);
     },
     async () => {
       await sync_engine(engine);
     }
   );

   await PlacesUtils.bookmarks.update({
     guid: bmk.guid,
     title: "New Title",
   });

   await store.wipe();
   await engine.resetClient();
   // We don't sync via the service, so don't re-hit info/collections, so
   // lastModified remaning at zero breaks things subtly...
   engine.lastModified = null;

   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.name, "bookmarks-buffered");
       equal(e.outgoing.length, 1);
       ok(!!e.incoming);
     },
     async () => {
       await sync_engine(engine);
     }
   );
 } finally {
   // Clean up.
   await store.wipe();
   await cleanAndGo(engine, server);
 }
});

add_task(async function test_upload_failed() {
 let collection = new ServerCollection();
 collection._wbos.flying = new ServerWBO("flying");

 let server = sync_httpd_setup({
   "/1.1/foo/storage/rotary": collection.handler(),
 });

 await SyncTestingInfrastructure(server);
 await configureIdentity({ username: "foo" }, server);

 let engine = new RotaryEngine(Service);
 engine._store.items = {
   flying: "LNER Class A3 4472",
   scotsman: "Flying Scotsman",
   peppercorn: "Peppercorn Class",
 };
 const FLYING_CHANGED = 12345;
 const SCOTSMAN_CHANGED = 23456;
 const PEPPERCORN_CHANGED = 34567;
 await engine._tracker.addChangedID("flying", FLYING_CHANGED);
 await engine._tracker.addChangedID("scotsman", SCOTSMAN_CHANGED);
 await engine._tracker.addChangedID("peppercorn", PEPPERCORN_CHANGED);

 let syncID = await engine.resetLocalSyncID();
 let meta_global = Service.recordManager.set(
   engine.metaURL,
   new WBORecord(engine.metaURL)
 );
 meta_global.payload.engines = { rotary: { version: engine.version, syncID } };

 try {
   await engine.setLastSync(123); // needs to be non-zero so that tracker is queried
   let changes = await engine._tracker.getChangedIDs();
   _(
     `test_upload_failed: Rotary tracker contents at first sync: ${JSON.stringify(
       changes
     )}`
   );
   engine.enabled = true;
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.incoming, null);
       deepEqual(e.outgoing, [
         {
           sent: 3,
           failed: 2,
           failedReasons: [
             { name: "scotsman", count: 1 },
             { name: "peppercorn", count: 1 },
           ],
         },
       ]);
     },
     async () => {
       await sync_engine(engine);
     }
   );

   await engine.setLastSync(123);

   changes = await engine._tracker.getChangedIDs();
   _(
     `test_upload_failed: Rotary tracker contents at second sync: ${JSON.stringify(
       changes
     )}`
   );
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       deepEqual(e.outgoing, [
         {
           sent: 2,
           failed: 2,
           failedReasons: [
             { name: "scotsman", count: 1 },
             { name: "peppercorn", count: 1 },
           ],
         },
       ]);
     },
     async () => {
       await sync_engine(engine);
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await engine.finalize();
 }
});

add_task(async function test_sync_partialUpload() {
 let collection = new ServerCollection();
 let server = sync_httpd_setup({
   "/1.1/foo/storage/rotary": collection.handler(),
 });
 await SyncTestingInfrastructure(server);
 await generateNewKeys(Service.collectionKeys);

 let engine = new RotaryEngine(Service);
 await engine.setLastSync(123);

 // Create a bunch of records (and server side handlers)
 for (let i = 0; i < 234; i++) {
   let id = "record-no-" + i;
   engine._store.items[id] = "Record No. " + i;
   await engine._tracker.addChangedID(id, i);
   // Let two items in the first upload batch fail.
   if (i != 23 && i != 42) {
     collection.insert(id);
   }
 }

 let syncID = await engine.resetLocalSyncID();
 let meta_global = Service.recordManager.set(
   engine.metaURL,
   new WBORecord(engine.metaURL)
 );
 meta_global.payload.engines = { rotary: { version: engine.version, syncID } };

 try {
   let changes = await engine._tracker.getChangedIDs();
   _(
     `test_sync_partialUpload: Rotary tracker contents at first sync: ${JSON.stringify(
       changes
     )}`
   );
   engine.enabled = true;
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       ok(!sync.failureReason);
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.name, "rotary");
       ok(!e.incoming);
       ok(!e.failureReason);
       deepEqual(e.outgoing, [
         {
           sent: 234,
           failed: 2,
           failedReasons: [
             { name: "record-no-23", count: 1 },
             { name: "record-no-42", count: 1 },
           ],
         },
       ]);
     },
     async () => {
       await sync_engine(engine);
     }
   );

   collection.post = function () {
     throw new Error("Failure");
   };

   engine._store.items["record-no-1000"] = "Record No. 1000";
   await engine._tracker.addChangedID("record-no-1000", 1000);
   collection.insert("record-no-1000", 1000);

   await engine.setLastSync(123);

   changes = await engine._tracker.getChangedIDs();
   _(
     `test_sync_partialUpload: Rotary tracker contents at second sync: ${JSON.stringify(
       changes
     )}`
   );
   // It would be nice if we had a more descriptive error for this...
   const uploadFailureError = {
     name: "httperror",
     code: 500,
   };
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       deepEqual(sync.failureReason, uploadFailureError);
       equal(sync.engines.length, 1);

       const e = sync.engines[0];
       equal(e.name, "rotary");
       deepEqual(e.incoming, {
         failed: 1,
         failedReasons: [
           { name: "No ciphertext: nothing to decrypt?", count: 1 },
         ],
       });
       ok(!e.outgoing);
       deepEqual(e.failureReason, uploadFailureError);
     },
     async () => {
       await sync_engine(engine, /500 Internal Server Error/);
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await engine.finalize();
 }
});

add_task(async function test_generic_engine_fail() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 let e = new Error("generic failure message");
 engine._errToThrow = e;

 try {
   const changes = await engine._tracker.getChangedIDs();
   _(
     `test_generic_engine_fail: Steam tracker contents: ${JSON.stringify(
       changes
     )}`
   );
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       deepEqual(
         sync.engines.find(err => err.name === "steam").failureReason,
         {
           name: "unexpectederror",
           error: String(e),
         }
       );
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_engine_fail_weird_errors() {
 enableValidationPrefs();
 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 try {
   let msg = "Bad things happened!";
   engine._errToThrow = { message: msg };
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       deepEqual(
         sync.engines.find(err => err.name === "steam").failureReason,
         {
           name: "unexpectederror",
           error: msg,
         }
       );
     },
     async () => {
       await Service.sync();
     }
   );
   let e = { msg };
   engine._errToThrow = e;
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       deepEqual(
         sync.engines.find(err => err.name === "steam").failureReason,
         {
           name: "unexpectederror",
           error: JSON.stringify(e),
         }
       );
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   Service.engineManager.unregister(engine);
 }
});

add_task(async function test_overrideTelemetryName() {
 enableValidationPrefs(["steam"]);

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.overrideTelemetryName = "steam-but-better";
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);

 const problemsToReport = [
   { name: "someProblem", count: 123 },
   { name: "anotherProblem", count: 456 },
 ];

 try {
   info("Sync with validation problems");
   engine.problemsToReport = problemsToReport;
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       ok(!sync.engines.find(e => e.name === "steam"));
       const eng = sync.engines.find(e => e.name === "steam-but-better");
       ok(eng);
       delete eng.validation.took; // can't compare real times.
       deepEqual(
         eng.validation,
         {
           version: 1,
           checked: 0,
           problems: problemsToReport,
         },
         "Should include validation report with overridden name"
       );
     },
     async () => {
       await Service.sync();
     }
   );

   info("Sync without validation problems");
   engine.problemsToReport = null;
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       ok(!sync.engines.find(e => e.name === "steam"));
       const eng = sync.engines.find(e => e.name === "steam-but-better");
       ok(eng);
       ok(
         !eng.validation,
         "Should not include validation report when there are no problems"
       );
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_engine_fail_ioerror() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 // create an IOError to re-throw as part of Sync.
 try {
   // (Note that fakeservices.js has replaced Utils.jsonMove etc, but for
   // this test we need the real one so we get real exceptions from the
   // filesystem.)
   await Utils._real_jsonMove("file-does-not-exist", "anything", {});
 } catch (ex) {
   engine._errToThrow = ex;
 }
 ok(engine._errToThrow, "expecting exception");

 try {
   const changes = await engine._tracker.getChangedIDs();
   _(
     `test_engine_fail_ioerror: Steam tracker contents: ${JSON.stringify(
       changes
     )}`
   );
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       const failureReason = sync.engines.find(
         e => e.name === "steam"
       ).failureReason;
       equal(failureReason.name, "unexpectederror");
       // ensure the profile dir in the exception message has been stripped.
       ok(
         !failureReason.error.includes(PathUtils.profileDir),
         failureReason.error
       );
       ok(failureReason.error.includes("[profileDir]"), failureReason.error);
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_clean_urls() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 engine._errToThrow = new TypeError(
   "http://www.google .com is not a valid URL."
 );

 try {
   const changes = await engine._tracker.getChangedIDs();
   _(`test_clean_urls: Steam tracker contents: ${JSON.stringify(changes)}`);
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       const failureReason = sync.engines.find(
         e => e.name === "steam"
       ).failureReason;
       equal(failureReason.name, "unexpectederror");
       equal(failureReason.error, "<URL> is not a valid URL.");
     },
     async () => {
       await Service.sync();
     }
   );
   // Handle other errors that include urls.
   engine._errToThrow =
     "Other error message that includes some:url/foo/bar/ in it.";
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       const failureReason = sync.engines.find(
         e => e.name === "steam"
       ).failureReason;
       equal(failureReason.name, "unexpectederror");
       equal(
         failureReason.error,
         "Other error message that includes <URL> in it."
       );
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

// Arrange for a sync to hit a "real" OS error during a sync and make sure it's sanitized.
add_task(async function test_clean_real_os_error() {
 enableValidationPrefs();

 // Simulate a real error.
 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 let path = PathUtils.join(PathUtils.profileDir, "no", "such", "path.json");
 try {
   await IOUtils.readJSON(path);
   throw new Error("should fail to read the file");
 } catch (ex) {
   engine._errToThrow = ex;
 }

 try {
   const changes = await engine._tracker.getChangedIDs();
   _(`test_clean_urls: Steam tracker contents: ${JSON.stringify(changes)}`);
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       const failureReason = sync.engines.find(
         e => e.name === "steam"
       ).failureReason;
       equal(failureReason.name, "unexpectederror");
       equal(
         failureReason.error,
         "OS error [File/Path not found] Could not open `[profileDir]/no/such/path.json': file does not exist"
       );
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_initial_sync_engines() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 // These are the only ones who actually have things to sync at startup.
 let telemetryEngineNames = ["clients", "prefs", "tabs", "bookmarks-buffered"];
 let server = await serverForEnginesWithKeys(
   { foo: "password" },
   ["bookmarks", "prefs", "tabs"].map(name => Service.engineManager.get(name))
 );
 await SyncTestingInfrastructure(server);
 try {
   const changes = await engine._tracker.getChangedIDs();
   _(
     `test_initial_sync_engines: Steam tracker contents: ${JSON.stringify(
       changes
     )}`
   );
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.engines.find(e => e.name === "clients").outgoing[0].sent, 1);
       equal(sync.engines.find(e => e.name === "tabs").outgoing[0].sent, 1);

       sync.engines
         .filter(e => telemetryEngineNames.includes(e.name))
         .forEach(e => {
           greaterOrEqual(e.took, 0);
           ok(!!e.outgoing);
           equal(e.outgoing.length, 1);
           notEqual(e.outgoing[0].sent, undefined);
           equal(e.outgoing[0].failed, undefined);
           equal(e.outgoing[0].failedReasons, undefined);
         });
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_nserror() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 engine._errToThrow = Components.Exception(
   "NS_ERROR_UNKNOWN_HOST",
   Cr.NS_ERROR_UNKNOWN_HOST
 );
 try {
   const changes = await engine._tracker.getChangedIDs();
   _(`test_nserror: Steam tracker contents: ${JSON.stringify(changes)}`);
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       deepEqual(sync.status, {
         service: SYNC_FAILED_PARTIAL,
         sync: LOGIN_FAILED_NETWORK_ERROR,
       });
       const eng = sync.engines.find(e => e.name === "steam");
       deepEqual(eng.failureReason, {
         name: "httperror",
         code: Cr.NS_ERROR_UNKNOWN_HOST,
       });
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_sync_why() {
 enableValidationPrefs();

 await Service.engineManager.register(SteamEngine);
 let engine = Service.engineManager.get("steam");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 await SyncTestingInfrastructure(server);
 let e = new Error("generic failure message");
 engine._errToThrow = e;

 try {
   const changes = await engine._tracker.getChangedIDs();
   _(
     `test_generic_engine_fail: Steam tracker contents: ${JSON.stringify(
       changes
     )}`
   );
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.hashedFxaUid.testGetValue(), "f".repeat(32));

       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);

       const sync = syncs[0];
       equal(sync.why, "user");
     },
     async () => {
       await Service.sync({ why: "user" });
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await 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 server;
 try {
   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()
     ),
   };

   let collections = [
     "clients",
     "bookmarks",
     "forms",
     "history",
     "passwords",
     "prefs",
     "tabs",
   ];

   for (let coll of collections) {
     handlers["/1.1/johndoe/storage/" + coll] = upd(
       coll,
       new ServerCollection({}, true).handler()
     );
   }

   server = httpd_setup(handlers);
   await configureIdentity({ username: "johndoe" }, server);
   GleanPings.sync.testBeforeNextSubmit(() => {
     ok(false, "Submitted telemetry ping when we should not have.");
   });

   for (let i = 0; i < 5; ++i) {
     await Service.sync();
   }
   telem.submissionInterval = -1;

   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       equal(Glean.syncs.discarded.testGetValue(), 4);
       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 2);
       syncs.forEach(assert_success_sync);
     },
     async () => {
       await Service.sync(); // Sixth time's the charm.
     }
   );
 } finally {
   telem.maxPayloadCount = 500;
   telem.submissionInterval = -1;
   if (server) {
     await promiseStopServer(server);
   }
 }
});

add_task(async function test_no_foreign_engines_in_error_ping() {
 enableValidationPrefs();

 await Service.engineManager.register(BogusEngine);
 let engine = Service.engineManager.get("bogus");
 engine.enabled = true;
 let server = await serverForFoo(engine);
 engine._errToThrow = new Error("Oh no!");
 await SyncTestingInfrastructure(server);
 try {
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);
       const sync = syncs[0];
       equal(sync.status.service, SYNC_FAILED_PARTIAL);
       ok(sync.engines.every(e => e.name !== "bogus"));
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_no_foreign_engines_in_success_ping() {
 enableValidationPrefs();

 await Service.engineManager.register(BogusEngine);
 let engine = Service.engineManager.get("bogus");
 engine.enabled = true;
 let server = await serverForFoo(engine);

 await SyncTestingInfrastructure(server);
 try {
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "schedule");
       const syncs = Glean.syncs.syncs.testGetValue();
       equal(syncs.length, 1);
       const sync = syncs[0];
       ok(sync.engines.every(e => e.name !== "bogus"));
     },
     async () => {
       await Service.sync();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_no_node_type() {
 let server = sync_httpd_setup({});
 await configureIdentity(null, server);

 await GleanPings.sync.testSubmission(
   reason => {
     equal(reason, "schedule");
     Assert.strictEqual(Glean.syncs.syncNodeType.testGetValue(), null);
   },
   async () => {
     await Service.sync();
   }
 );
 await promiseStopServer(server);
});

add_task(async function test_node_type() {
 Service.identity.logout();
 let server = sync_httpd_setup({});
 await configureIdentity({ node_type: "the-node-type" }, server);

 await GleanPings.sync.testSubmission(
   reason => {
     equal(reason, "schedule");
     equal(Glean.syncs.syncNodeType.testGetValue(), "the-node-type");
   },
   async () => {
     await Service.sync();
   }
 );
 await promiseStopServer(server);
});

add_task(async function test_node_type_change() {
 Service.identity.logout();
 let server = sync_httpd_setup({});
 await configureIdentity({ node_type: "first-node-type" }, server);
 // Default to submitting each hour - we should still submit on node change.
 let telem = get_sync_test_telemetry();
 telem.submissionInterval = 60 * 60 * 1000;
 // reset the node type from previous test or our first sync will submit.
 telem.lastSyncNodeType = null;
 // do 2 syncs with the same node type.
 await Service.sync();
 await Service.sync();
 // then another with a different node type.
 Service.identity.logout();
 await configureIdentity({ node_type: "second-node-type" }, server);
 await GleanPings.sync.testSubmission(
   () => {
     equal(
       Glean.syncs.syncs.testGetValue().length,
       2,
       "2 syncs in first ping"
     );
     equal(Glean.syncs.syncNodeType.testGetValue(), "first-node-type");
   },
   async () => {
     await Service.sync();
   }
 );
 await GleanPings.sync.testSubmission(
   () => {
     equal(
       Glean.syncs.syncs.testGetValue().length,
       1,
       "1 sync in second ping"
     );
     equal(Glean.syncs.syncNodeType.testGetValue(), "second-node-type");
   },
   async () => {
     telem.finish();
   }
 );
 await promiseStopServer(server);
});

add_task(async function test_uid_change() {
 enableValidationPrefs();

 await Service.engineManager.register(BogusEngine);
 let engine = Service.engineManager.get("bogus");
 engine.enabled = true;
 let server = await serverForFoo(engine);

 await SyncTestingInfrastructure(server);
 let telem = get_sync_test_telemetry();
 telem.maxPayloadCount = 500;
 telem.submissionInterval = Infinity;

 // a sync with the "old" uid.
 await Service.sync();

 fxAccounts.telemetry._setHashedUID("deadbeef");

 try {
   await GleanPings.sync.testSubmission(
     reason => {
       equal(reason, "idchange");
       equal(
         Glean.syncs.syncs.testGetValue().length,
         1,
         "first sync in its own ping"
       );
     },
     async () => {
       await Service.sync();
     }
   );
   await GleanPings.sync.testSubmission(
     () => {
       equal(
         Glean.syncs.syncs.testGetValue().length,
         1,
         "second sync in its own ping"
       );
     },
     async () => {
       telem.finish();
     }
   );
 } finally {
   await cleanAndGo(engine, server);
   await Service.engineManager.unregister(engine);
 }
});

add_task(async function test_deletion_request_ping() {
 async function assertRecordedSyncDeviceID(expected) {
   // `onAccountInitOrChange` sets the id asynchronously, so wait a tick.
   await Promise.resolve();
   equal(Glean.deletionRequest.syncDeviceId.testGetValue(), expected);
 }
 Services.fog.testResetFOG();

 const MOCK_HASHED_UID = "00112233445566778899aabbccddeeff";
 const MOCK_DEVICE_ID1 = "ffeeddccbbaa99887766554433221100";
 const MOCK_DEVICE_ID2 = "aabbccddeeff99887766554433221100";

 // Calculated by hand using SHA256(DEVICE_ID + HASHED_UID)[:32]
 const SANITIZED_DEVICE_ID1 = "dd7c845006df9baa1c6d756926519c8c";
 const SANITIZED_DEVICE_ID2 = "0d06919a736fc029007e1786a091882c";

 let currentDeviceID = null;
 sinon.stub(fxAccounts.device, "getLocalId").callsFake(() => {
   return Promise.resolve(currentDeviceID);
 });
 let telem = get_sync_test_telemetry();
 sinon.stub(telem, "isProductionSyncUser").callsFake(() => true);
 fxAccounts.telemetry._setHashedUID(false);

 try {
   // The scalar should start out undefined, since no user is actually logged in.
   await assertRecordedSyncDeviceID(null);

   // If we start up without knowing the hashed UID, it should stay undefined.
   telem.observe(null, "weave:service:ready");
   await assertRecordedSyncDeviceID(null);

   // But now let's say we've discovered the hashed UID from the server.
   fxAccounts.telemetry._setHashedUID(MOCK_HASHED_UID);
   currentDeviceID = MOCK_DEVICE_ID1;

   // Now when we load up, we'll record the sync device id.
   telem.observe(null, "weave:service:ready");
   await assertRecordedSyncDeviceID(SANITIZED_DEVICE_ID1);

   // When the device-id changes we'll update it.
   currentDeviceID = MOCK_DEVICE_ID2;
   telem.observe(null, "fxaccounts:new_device_id");
   await assertRecordedSyncDeviceID(SANITIZED_DEVICE_ID2);

   // When the user signs out we'll clear it.
   telem.observe(null, "fxaccounts:onlogout");
   await assertRecordedSyncDeviceID("");
 } finally {
   fxAccounts.telemetry._setHashedUID(false);
   telem.isProductionSyncUser.restore();
   fxAccounts.device.getLocalId.restore();
 }
});

// TODO: Is the topic `"weave:telemetry:migration"` presently hooked up?
add_task(async function test_migration() {
 let telem = get_sync_test_telemetry();
 const migrationInfo = {
   entries: 42,
   entries_successful: 42,
   extensions: 84,
   extensions_successful: 83,
   openFailure: false,
 };
 telem._addMigrationRecord("webext-storage", migrationInfo);
 await GleanPings.sync.testSubmission(
   () => {
     const migrations = Glean.syncs.migrations.testGetValue();
     equal(migrations.length, 1);
     deepEqual(migrations[0], {
       migration_type: "webext-storage",
       entries: 42,
       entriesSuccessful: 42,
       extensions: 84,
       extensionsSuccessful: 83,
       openFailure: false,
     });
   },
   () => {
     telem.finish();
   }
 );
});