The Tor Browser: services/sync/tests/unit/test

     1 /* Any copyright is dedicated to the Public Domain.

     2    http://creativecommons.org/publicdomain/zero/1.0/ */

     4 Cu.import("resource://services-common/observers.js");

     5 Cu.import("resource://services-sync/engines.js");

     6 Cu.import("resource://services-sync/service.js");

     7 Cu.import("resource://services-sync/util.js");

     9 function SteamStore(engine) {

    10   Store.call(this, "Steam", engine);

    11   this.wasWiped = false;

    12 }

    13 SteamStore.prototype = {

    14   __proto__: Store.prototype,

    16   wipe: function() {

    17     this.wasWiped = true;

    18   }

    19 };

    21 function SteamTracker(name, engine) {

    22   Tracker.call(this, name || "Steam", engine);

    23 }

    24 SteamTracker.prototype = {

    25   __proto__: Tracker.prototype

    26 };

    28 function SteamEngine(service) {

    29   Engine.call(this, "Steam", service);

    30   this.wasReset = false;

    31   this.wasSynced = false;

    32 }

    33 SteamEngine.prototype = {

    34   __proto__: Engine.prototype,

    35   _storeObj: SteamStore,

    36   _trackerObj: SteamTracker,

    38   _resetClient: function () {

    39     this.wasReset = true;

    40   },

    42   _sync: function () {

    43     this.wasSynced = true;

    44   }

    45 };

    47 let engineObserver = {

    48   topics: [],

    50   observe: function(subject, topic, data) {

    51     do_check_eq(data, "steam");

    52     this.topics.push(topic);

    53   },

    55   reset: function() {

    56     this.topics = [];

    57   }

    58 };

    59 Observers.add("weave:engine:reset-client:start", engineObserver);

    60 Observers.add("weave:engine:reset-client:finish", engineObserver);

    61 Observers.add("weave:engine:wipe-client:start", engineObserver);

    62 Observers.add("weave:engine:wipe-client:finish", engineObserver);

    63 Observers.add("weave:engine:sync:start", engineObserver);

    64 Observers.add("weave:engine:sync:finish", engineObserver);

    66 function run_test() {

    67   run_next_test();

    68 }

    70 add_test(function test_members() {

    71   _("Engine object members");

    72   let engine = new SteamEngine(Service);

    73   do_check_eq(engine.Name, "Steam");

    74   do_check_eq(engine.prefName, "steam");

    75   do_check_true(engine._store instanceof SteamStore);

    76   do_check_true(engine._tracker instanceof SteamTracker);

    77   run_next_test();

    78 });

    80 add_test(function test_score() {

    81   _("Engine.score corresponds to tracker.score and is readonly");

    82   let engine = new SteamEngine(Service);

    83   do_check_eq(engine.score, 0);

    84   engine._tracker.score += 5;

    85   do_check_eq(engine.score, 5);

    87   try {

    88     engine.score = 10;

    89   } catch(ex) {

    90     // Setting an attribute that has a getter produces an error in

    91     // Firefox <= 3.6 and is ignored in later versions.  Either way,

    92     // the attribute's value won't change.

    93   }

    94   do_check_eq(engine.score, 5);

    95   run_next_test();

    96 });

    98 add_test(function test_resetClient() {

    99   _("Engine.resetClient calls _resetClient");

   100   let engine = new SteamEngine(Service);

   101   do_check_false(engine.wasReset);

   103   engine.resetClient();

   104   do_check_true(engine.wasReset);

   105   do_check_eq(engineObserver.topics[0], "weave:engine:reset-client:start");

   106   do_check_eq(engineObserver.topics[1], "weave:engine:reset-client:finish");

   108   engine.wasReset = false;

   109   engineObserver.reset();

   110   run_next_test();

   111 });

   113 add_test(function test_invalidChangedIDs() {

   114   _("Test that invalid changed IDs on disk don't end up live.");

   115   let engine = new SteamEngine(Service);

   116   let tracker = engine._tracker;

   117   tracker.changedIDs = 5;

   118   tracker.saveChangedIDs(function onSaved() {

   119       tracker.changedIDs = {placeholder: true};

   120       tracker.loadChangedIDs(function onLoaded(json) {

   121         do_check_null(json);

   122         do_check_true(tracker.changedIDs.placeholder);

   123         run_next_test();

   124       });

   125     });

   126 });

   128 add_test(function test_wipeClient() {

   129   _("Engine.wipeClient calls resetClient, wipes store, clears changed IDs");

   130   let engine = new SteamEngine(Service);

   131   do_check_false(engine.wasReset);

   132   do_check_false(engine._store.wasWiped);

   133   do_check_true(engine._tracker.addChangedID("a-changed-id"));

   134   do_check_true("a-changed-id" in engine._tracker.changedIDs);

   136   engine.wipeClient();

   137   do_check_true(engine.wasReset);

   138   do_check_true(engine._store.wasWiped);

   139   do_check_eq(JSON.stringify(engine._tracker.changedIDs), "{}");

   140   do_check_eq(engineObserver.topics[0], "weave:engine:wipe-client:start");

   141   do_check_eq(engineObserver.topics[1], "weave:engine:reset-client:start");

   142   do_check_eq(engineObserver.topics[2], "weave:engine:reset-client:finish");

   143   do_check_eq(engineObserver.topics[3], "weave:engine:wipe-client:finish");

   145   engine.wasReset = false;

   146   engine._store.wasWiped = false;

   147   engineObserver.reset();

   148   run_next_test();

   149 });

   151 add_test(function test_enabled() {

   152   _("Engine.enabled corresponds to preference");

   153   let engine = new SteamEngine(Service);

   154   try {

   155     do_check_false(engine.enabled);

   156     Svc.Prefs.set("engine.steam", true);

   157     do_check_true(engine.enabled);

   159     engine.enabled = false;

   160     do_check_false(Svc.Prefs.get("engine.steam"));

   161     run_next_test();

   162   } finally {

   163     Svc.Prefs.resetBranch("");

   164   }

   165 });

   167 add_test(function test_sync() {

   168   let engine = new SteamEngine(Service);

   169   try {

   170     _("Engine.sync doesn't call _sync if it's not enabled");

   171     do_check_false(engine.enabled);

   172     do_check_false(engine.wasSynced);

   173     engine.sync();

   174     do_check_false(engine.wasSynced);

   176     _("Engine.sync calls _sync if it's enabled");

   177     engine.enabled = true;

   178     engine.sync();

   179     do_check_true(engine.wasSynced);

   180     do_check_eq(engineObserver.topics[0], "weave:engine:sync:start");

   181     do_check_eq(engineObserver.topics[1], "weave:engine:sync:finish");

   182     run_next_test();

   183   } finally {

   184     Svc.Prefs.resetBranch("");

   185     engine.wasSynced = false;

   186     engineObserver.reset();

   187   }

   188 });

   190 add_test(function test_disabled_no_track() {

   191   _("When an engine is disabled, its tracker is not tracking.");

   192   let engine = new SteamEngine(Service);

   193   let tracker = engine._tracker;

   194   do_check_eq(engine, tracker.engine);

   196   do_check_false(engine.enabled);

   197   do_check_false(tracker._isTracking);

   198   do_check_empty(tracker.changedIDs);

   200   do_check_false(tracker.engineIsEnabled());

   201   tracker.observe(null, "weave:engine:start-tracking", null);

   202   do_check_false(tracker._isTracking);

   203   do_check_empty(tracker.changedIDs);

   205   engine.enabled = true;

   206   tracker.observe(null, "weave:engine:start-tracking", null);

   207   do_check_true(tracker._isTracking);

   208   do_check_empty(tracker.changedIDs);

   210   tracker.addChangedID("abcdefghijkl");

   211   do_check_true(0 < tracker.changedIDs["abcdefghijkl"]);

   212   engine.enabled = false;

   213   do_check_false(tracker._isTracking);

   214   do_check_empty(tracker.changedIDs);

   216   run_next_test();

   217 });

The Tor Browser / file revision