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

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

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

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

     4 "use strict";

     6 Cu.import("resource://gre/modules/Metrics.jsm", this);

     7 Cu.import("resource://gre/modules/Preferences.jsm", this);

     8 Cu.import("resource://gre/modules/Promise.jsm", this);

     9 Cu.import("resource://services-sync/main.js", this);

    10 Cu.import("resource://services-sync/healthreport.jsm", this);

    11 Cu.import("resource://testing-common/services-common/logging.js", this);

    12 Cu.import("resource://testing-common/services/healthreport/utils.jsm", this);

    14 function run_test() {

    15   initTestLogging();

    17   run_next_test();

    18 }

    20 add_task(function test_constructor() {

    21   let provider = new SyncProvider();

    22 });

    24 // Provider can initialize and de-initialize properly.

    25 add_task(function* test_init() {

    26   let storage = yield Metrics.Storage("init");

    27   let provider = new SyncProvider();

    28   yield provider.init(storage);

    29   yield provider.shutdown();

    30   yield storage.close();

    31 });

    33 add_task(function* test_collect() {

    34   let storage = yield Metrics.Storage("collect");

    35   let provider = new SyncProvider();

    36   yield provider.init(storage);

    38   // Initially nothing should be configured.

    39   let now = new Date();

    40   yield provider.collectDailyData();

    42   let m = provider.getMeasurement("sync", 1);

    43   let values = yield m.getValues();

    44   Assert.equal(values.days.size, 1);

    45   Assert.ok(values.days.hasDay(now));

    46   let day = values.days.getDay(now);

    47   Assert.ok(day.has("enabled"));

    48   Assert.ok(day.has("activeProtocol"));

    49   Assert.ok(day.has("preferredProtocol"));

    50   Assert.equal(day.get("enabled"), 0);

    51   Assert.equal(day.get("preferredProtocol"), "1.5");

    52   Assert.equal(day.get("activeProtocol"), "1.5",

    53                "Protocol without setup should be FX Accounts version.");

    55   // Now check for old Sync setup.

    56   let branch = new Preferences("services.sync.");

    57   branch.set("username", "foo");

    58   branch.reset("fxaccounts.enabled");

    59   yield provider.collectDailyData();

    60   values = yield m.getValues();

    61   Assert.equal(values.days.getDay(now).get("activeProtocol"), "1.1",

    62                "Protocol with old Sync setup is correct.");

    64   Assert.equal(Weave.Status.__authManager, undefined, "Detect code changes");

    66   // Let's enable Sync so we can get more useful data.

    67   // We need to do this because the FHR probe only records more info if Sync

    68   // is configured properly.

    69   Weave.Service.identity.account = "johndoe";

    70   Weave.Service.identity.basicPassword = "ilovejane";

    71   Weave.Service.identity.syncKey = Weave.Utils.generatePassphrase();

    72   Weave.Service.clusterURL = "http://localhost/";

    73   Assert.equal(Weave.Status.checkSetup(), Weave.STATUS_OK);

    75   yield provider.collectDailyData();

    76   values = yield m.getValues();

    77   day = values.days.getDay(now);

    78   Assert.equal(day.get("enabled"), 1);

    80   // An empty account should have 1 device: us.

    81   let dm = provider.getMeasurement("devices", 1);

    82   values = yield dm.getValues();

    83   Assert.ok(values.days.hasDay(now));

    84   day = values.days.getDay(now);

    85   Assert.equal(day.size, 1);

    86   let engine = Weave.Service.clientsEngine;

    87   Assert.ok(engine);

    88   Assert.ok(day.has(engine.localType));

    89   Assert.equal(day.get(engine.localType), 1);

    91   // Add some devices and ensure they show up.

    92   engine._store._remoteClients["id1"] = {type: "mobile"};

    93   engine._store._remoteClients["id2"] = {type: "tablet"};

    94   engine._store._remoteClients["id3"] = {type: "mobile"};

    96   yield provider.collectDailyData();

    97   values = yield dm.getValues();

    98   day = values.days.getDay(now);

   100   let expected = {

   101     "foobar": 0,

   102     "tablet": 1,

   103     "mobile": 2,

   104     "desktop": 0,

   105   };

   107   for (let type in expected) {

   108     let count = expected[type];

   110     if (engine.localType == type) {

   111       count++;

   112     }

   114     if (!count) {

   115       Assert.ok(!day.has(type));

   116     } else {

   117       Assert.ok(day.has(type));

   118       Assert.equal(day.get(type), count);

   119     }

   120   }

   122   engine._store._remoteClients = {};

   124   yield provider.shutdown();

   125   yield storage.close();

   126 });

   128 add_task(function* test_sync_events() {

   129   let storage = yield Metrics.Storage("sync_events");

   130   let provider = new SyncProvider();

   131   yield provider.init(storage);

   133   let m = provider.getMeasurement("sync", 1);

   135   for (let i = 0; i < 5; i++) {

   136     Services.obs.notifyObservers(null, "weave:service:sync:start", null);

   137   }

   139   for (let i = 0; i < 3; i++) {

   140     Services.obs.notifyObservers(null, "weave:service:sync:finish", null);

   141   }

   143   for (let i = 0; i < 2; i++) {

   144     Services.obs.notifyObservers(null, "weave:service:sync:error", null);

   145   }

   147   // Wait for storage to complete.

   148   yield m.storage.enqueueOperation(() => {

   149     return Promise.resolve();

   150   });

   152   let values = yield m.getValues();

   153   let now = new Date();

   154   Assert.ok(values.days.hasDay(now));

   155   let day = values.days.getDay(now);

   157   Assert.ok(day.has("syncStart"));

   158   Assert.ok(day.has("syncSuccess"));

   159   Assert.ok(day.has("syncError"));

   160   Assert.equal(day.get("syncStart"), 5);

   161   Assert.equal(day.get("syncSuccess"), 3);

   162   Assert.equal(day.get("syncError"), 2);

   164   yield provider.shutdown();

   165   yield storage.close();

   166 });

   168 add_task(function* test_healthreporter_json() {

   169   let reporter = yield getHealthReporter("healthreporter_json");

   170   yield reporter.init();

   171   try {

   172     yield reporter._providerManager.registerProvider(new SyncProvider());

   173     yield reporter.collectMeasurements();

   174     let payload = yield reporter.getJSONPayload(true);

   175     let now = new Date();

   176     let today = reporter._formatDate(now);

   178     Assert.ok(today in payload.data.days);

   179     let day = payload.data.days[today];

   181     Assert.ok("org.mozilla.sync.sync" in day);

   182     Assert.ok("org.mozilla.sync.devices" in day);

   184     let devices = day["org.mozilla.sync.devices"];

   185     let engine = Weave.Service.clientsEngine;

   186     Assert.ok(engine);

   187     let type = engine.localType;

   188     Assert.ok(type);

   189     Assert.ok(type in devices);

   190     Assert.equal(devices[type], 1);

   191   } finally {

   192     reporter._shutdown();

   193   }

   194 });

The Tor Browser / file revision