Bug 557588 - code audit and create unit test plan for engines.js [r=mconnor]

Tests for EngineMangerSvc, Engine and SyncEngine sans sync().

services/sync/modules/engines.js

@@ -151,7 +151,7 @@ Engine.prototype = {
   _trackerObj: Tracker,
 
   get prefName() this.name,
-  get enabled() Svc.Prefs.get("engine." + this.prefName, null),
+  get enabled() Svc.Prefs.get("engine." + this.prefName, false),
   set enabled(val) Svc.Prefs.set("engine." + this.prefName, !!val),
 
   get score() this._tracker.score,

services/sync/tests/unit/test_engine.js

@@ -0,0 +1,169 @@
+Cu.import("resource://weave/util.js");
+Cu.import("resource://weave/stores.js");
+Cu.import("resource://weave/trackers.js");
+Cu.import("resource://weave/engines.js");
+Cu.import("resource://weave/ext/Observers.js");
+
+
+function SteamStore() {
+  Store.call(this, "Steam");
+  this.wasWiped = false;
+}
+SteamStore.prototype = {
+  __proto__: Store.prototype,
+
+  wipe: function() {
+    this.wasWiped = true;
+  }
+};
+
+function SteamTracker() {
+  Tracker.call(this, "Steam");
+}
+SteamTracker.prototype = {
+  __proto__: Tracker.prototype
+};
+
+function SteamEngine() {
+  Engine.call(this, "Steam");
+  this.wasReset = false;
+  this.wasSynced = false;
+}
+SteamEngine.prototype = {
+  __proto__: Engine.prototype,
+  _storeObj: SteamStore,
+  _trackerObj: SteamTracker,
+
+  _resetClient: function () {
+    this.wasReset = true;
+  },
+
+  _sync: function () {
+    this.wasSynced = true;
+  }
+};
+
+let engineObserver = {
+  topics: [],
+
+  observe: function(subject, topic, data) {
+    do_check_eq(subject, "steam");
+    this.topics.push(topic);
+  },
+
+  reset: function() {
+    this.topics = [];
+  }
+};
+Observers.add("weave:engine:reset-client:start", engineObserver);
+Observers.add("weave:engine:reset-client:finish", engineObserver);
+Observers.add("weave:engine:wipe-client:start", engineObserver);
+Observers.add("weave:engine:wipe-client:finish", engineObserver);
+Observers.add("weave:engine:sync:start", engineObserver);
+Observers.add("weave:engine:sync:finish", engineObserver);
+
+
+function do_check_throws(func) {
+  var raised = false;
+  try {
+    func();
+  } catch (ex) {
+    raised = true;
+  }
+  do_check_true(raised);
+}
+
+
+function test_members() {
+  _("Engine object members");
+  let engine = new SteamEngine();
+  do_check_eq(engine.displayName, "Steam");
+  do_check_eq(engine.prefName, "steam");
+  do_check_true(engine._store instanceof SteamStore);
+  do_check_true(engine._tracker instanceof SteamTracker);
+}
+
+function test_score() {
+  _("Engine.score corresponds to tracker.score and is readonly");
+  let engine = new SteamEngine();
+  do_check_eq(engine.score, 0);
+  engine._tracker.score += 5;
+  do_check_eq(engine.score, 5);
+
+  do_check_throws(function() {
+      engine.score = 10;
+  });
+}
+
+function test_resetClient() {
+  _("Engine.resetClient calls _resetClient");
+  let engine = new SteamEngine();
+  do_check_false(engine.wasReset);
+
+  engine.resetClient();
+  do_check_true(engine.wasReset);
+  do_check_eq(engineObserver.topics[0], "weave:engine:reset-client:start");
+  do_check_eq(engineObserver.topics[1], "weave:engine:reset-client:finish");
+
+  engine.wasReset = false;
+  engineObserver.reset();
+}
+
+function test_wipeClient() {
+  _("Engine.wipeClient calls resetClient, wipes store, clears changed IDs");
+  let engine = new SteamEngine();
+  do_check_false(engine.wasReset);
+  do_check_false(engine._store.wasWiped);
+  do_check_true(engine._tracker.addChangedID("a-changed-id"));
+  do_check_true("a-changed-id" in engine._tracker.changedIDs);
+
+  engine.wipeClient();
+  do_check_true(engine.wasReset);
+  do_check_true(engine._store.wasWiped);
+  do_check_eq(JSON.stringify(engine._tracker.changedIDs), "{}");
+  do_check_eq(engineObserver.topics[0], "weave:engine:wipe-client:start");
+  do_check_eq(engineObserver.topics[1], "weave:engine:reset-client:start");
+  do_check_eq(engineObserver.topics[2], "weave:engine:reset-client:finish");
+  do_check_eq(engineObserver.topics[3], "weave:engine:wipe-client:finish");
+
+  engine.wasReset = false;
+  engine._store.wasWiped = false;
+  engineObserver.reset();
+}
+
+function test_enabled() {
+  _("Engine.enabled corresponds to preference");
+  let engine = new SteamEngine();
+  try {
+    do_check_false(engine.enabled);
+    Svc.Prefs.set("engine.steam", true);
+    do_check_true(engine.enabled);
+
+    engine.enabled = false;
+    do_check_false(Svc.Prefs.get("engine.steam"));
+  } finally {
+    Svc.Prefs.reset("engine.steam");
+  }
+}
+
+function test_sync() {
+  let engine = new SteamEngine();
+  try {
+    _("Engine.sync doesn't call _sync if it's not enabled");
+    do_check_false(engine.enabled);
+    do_check_false(engine.wasSynced);
+    engine.sync();
+    do_check_false(engine.wasSynced);
+
+    _("Engine.sync calls _sync if it's enabled");
+    engine.enabled = true;
+    engine.sync();
+    do_check_true(engine.wasSynced);
+    do_check_eq(engineObserver.topics[0], "weave:engine:sync:start");
+    do_check_eq(engineObserver.topics[1], "weave:engine:sync:finish");
+  } finally {
+    Svc.Prefs.reset("engine.steam");
+    engine.wasSynced = false;
+    engineObserver.reset();
+  }
+}

services/sync/tests/unit/test_engine_lastSync.js

@@ -1,8 +0,0 @@
-Cu.import("resource://weave/engines.js");
-
-function run_test() {
-  // Make sure storing floats for lastSync stay as floats
-  let engine = new SyncEngine();
-  engine.lastSync = 123.45;
-  do_check_eq(engine.lastSync, 123.45);
-}

services/sync/tests/unit/test_enginemanager.js

@@ -0,0 +1,80 @@
+Cu.import("resource://weave/engines.js");
+
+function run_test() {
+  _("We start out with a clean slate");
+  let engines = Engines.getAll();
+  do_check_eq(engines.length, 0);
+  do_check_eq(Engines.get('dummy'), undefined);
+
+  _("Register an engine");
+  function DummyEngine() {}
+  DummyEngine.prototype.name = "dummy";
+  Engines.register(DummyEngine);
+  let dummy = Engines.get('dummy');
+  do_check_true(dummy instanceof DummyEngine);
+
+  engines = Engines.getAll();
+  do_check_eq(engines.length, 1);
+  do_check_eq(engines[0], dummy);
+
+  _("Register an already registered engine is ignored");
+  Engines.register(DummyEngine);
+  do_check_eq(Engines.get('dummy'), dummy);
+
+  _("Register multiple engines in one go");
+  function PetrolEngine() {}
+  PetrolEngine.prototype.name = "petrol";
+  function DieselEngine() {}
+  DieselEngine.prototype.name = "diesel";
+
+  Engines.register([PetrolEngine, DieselEngine]);
+  let petrol = Engines.get('petrol');
+  let diesel = Engines.get('diesel');
+  do_check_true(petrol instanceof PetrolEngine);
+  do_check_true(diesel instanceof DieselEngine);
+
+  engines = Engines.getAll();
+  do_check_eq(engines.length, 3);
+  do_check_neq(engines.indexOf(petrol), -1);
+  do_check_neq(engines.indexOf(diesel), -1);
+
+  _("Retrieve multiple engines in one go");
+  engines = Engines.get(["dummy", "diesel"]);
+  do_check_eq(engines.length, 2);
+  do_check_neq(engines.indexOf(dummy), -1);
+  do_check_neq(engines.indexOf(diesel), -1);
+
+  _("getEnabled() only returns enabled engines");
+  engines = Engines.getEnabled();
+  do_check_eq(engines.length, 0);
+
+  petrol.enabled = true;
+  engines = Engines.getEnabled();
+  do_check_eq(engines.length, 1);
+  do_check_eq(engines[0], petrol);
+
+  dummy.enabled = true;
+  diesel.enabled = true;
+  engines = Engines.getEnabled();
+  do_check_eq(engines.length, 3);
+
+  _("Unregister an engine by name");
+  Engines.unregister('dummy');
+  do_check_eq(Engines.get('dummy'), undefined);
+  engines = Engines.getAll();
+  do_check_eq(engines.length, 2);
+  do_check_eq(engines.indexOf(dummy), -1);
+
+  _("Unregister an engine by value");
+  // Engines.unregister() checks for instanceof Engine, so let's make one:
+  function ActualEngine() {}
+  ActualEngine.prototype = {__proto__: Engine.prototype,
+                            name: 'actual'};
+  Engines.register(ActualEngine);
+  let actual = Engines.get('actual');
+  do_check_true(actual instanceof ActualEngine);
+  do_check_true(actual instanceof Engine);
+
+  Engines.unregister(actual);
+  do_check_eq(Engines.get('actual'), undefined);
+}

services/sync/tests/unit/test_syncengine.js

@@ -0,0 +1,113 @@
+Cu.import("resource://weave/util.js");
+Cu.import("resource://weave/engines.js");
+
+function makeSteamEngine() {
+  return new SyncEngine('Steam');
+}
+
+var syncTesting = new SyncTestingInfrastructure(makeSteamEngine);
+
+function test_url_attributes() {
+  _("SyncEngine url attributes");
+  Svc.Prefs.set("clusterURL", "https://cluster/");
+  let engine = makeSteamEngine();
+  try {
+    do_check_eq(engine.storageURL, "https://cluster/1.0/foo/storage/");
+    do_check_eq(engine.engineURL, "https://cluster/1.0/foo/storage/steam");
+    do_check_eq(engine.cryptoMetaURL,
+                "https://cluster/1.0/foo/storage/crypto/steam");
+    do_check_eq(engine.metaURL, "https://cluster/1.0/foo/storage/meta/global");
+  } finally {
+    Svc.Prefs.reset("clusterURL");
+  }
+}
+
+function test_syncID() {
+  _("SyncEngine.syncID corresponds to preference");
+  let engine = makeSteamEngine();
+  try {
+    // Ensure pristine environment
+    do_check_eq(Svc.Prefs.get("steam.syncID"), undefined);
+
+    // Performing the first get on the attribute will generate a new GUID.
+    do_check_eq(engine.syncID, "fake-guid-0");
+    do_check_eq(Svc.Prefs.get("steam.syncID"), "fake-guid-0");
+
+    Svc.Prefs.set("steam.syncID", Utils.makeGUID());
+    do_check_eq(Svc.Prefs.get("steam.syncID"), "fake-guid-1");
+    do_check_eq(engine.syncID, "fake-guid-1");
+  } finally {
+    Svc.Prefs.reset("steam.syncID");
+    syncTesting = new SyncTestingInfrastructure(makeSteamEngine);
+  }
+}
+
+function test_lastSync() {
+  _("SyncEngine.lastSync corresponds to preference and stores floats");
+  let engine = makeSteamEngine();
+  try {
+    // Ensure pristine environment
+    do_check_eq(Svc.Prefs.get("steam.lastSync"), undefined);
+    do_check_eq(engine.lastSync, 0);
+
+    // Floats are properly stored as floats and synced with the preference
+    engine.lastSync = 123.45;
+    do_check_eq(engine.lastSync, 123.45);
+    do_check_eq(Svc.Prefs.get("steam.lastSync"), "123.45");
+
+    // resetLastSync() resets the value (and preference) to 0
+    engine.resetLastSync();
+    do_check_eq(engine.lastSync, 0);
+    do_check_eq(Svc.Prefs.get("steam.lastSync"), "0");
+  } finally {
+    Svc.Prefs.reset("steam.lastSync");
+  }
+}
+
+function test_toFetch() {
+  _("SyncEngine.toFetch corresponds to file on disk");
+  let engine = makeSteamEngine();
+  try {
+    // Ensure pristine environment
+    do_check_eq(engine.toFetch.length, 0);
+
+    // Write file to disk
+    let toFetch = [Utils.makeGUID(), Utils.makeGUID(), Utils.makeGUID()];
+    engine.toFetch = toFetch;
+    do_check_eq(engine.toFetch, toFetch);
+    let fakefile = syncTesting.fakeFilesystem.fakeContents[
+        "weave/toFetch/steam.json"];
+    do_check_eq(fakefile, JSON.stringify(toFetch));
+
+    // Read file from disk
+    toFetch = [Utils.makeGUID(), Utils.makeGUID()];
+    syncTesting.fakeFilesystem.fakeContents["weave/toFetch/steam.json"]
+        = JSON.stringify(toFetch);
+    engine.loadToFetch();
+    do_check_eq(engine.toFetch.length, 2);
+    do_check_eq(engine.toFetch[0], toFetch[0]);
+    do_check_eq(engine.toFetch[1], toFetch[1]);
+  } finally {
+    syncTesting = new SyncTestingInfrastructure(makeSteamEngine);
+  }
+}
+
+function test_resetClient() {
+  _("SyncEngine.resetClient resets lastSync and toFetch");
+  let engine = makeSteamEngine();
+  try {
+    // Ensure pristine environment
+    do_check_eq(Svc.Prefs.get("steam.lastSync"), undefined);
+    do_check_eq(engine.toFetch.length, 0);
+
+    engine.toFetch = [Utils.makeGUID(), Utils.makeGUID(), Utils.makeGUID()];
+    engine.lastSync = 123.45;
+
+    engine.resetClient();
+    do_check_eq(engine.lastSync, 0);
+    do_check_eq(engine.toFetch.length, 0);
+  } finally {
+    syncTesting = new SyncTestingInfrastructure(makeSteamEngine);
+    Svc.Prefs.reset("steam.lastSync");
+  }
+}