The Tor Browser: browser/experiments/test/xpcshell/test_previous

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/Promise.jsm");

     7 Cu.import("resource:///modules/experiments/Experiments.jsm");

     8 Cu.import("resource://testing-common/httpd.js");

    10 let gDataRoot;

    11 let gHttpServer;

    12 let gManifestObject;

    14 function run_test() {

    15   run_next_test();

    16 }

    18 add_task(function test_setup() {

    19   loadAddonManager();

    20   do_get_profile();

    22   gHttpServer = new HttpServer();

    23   gHttpServer.start(-1);

    24   let httpRoot = "http://localhost:" + gHttpServer.identity.primaryPort + "/";

    25   gDataRoot = httpRoot + "data/";

    26   gHttpServer.registerDirectory("/data/", do_get_cwd());

    27   gHttpServer.registerPathHandler("/manifests/handler", (req, res) => {

    28     res.setStatusLine(null, 200, "OK");

    29     res.write(JSON.stringify(gManifestObject));

    30     res.processAsync();

    31     res.finish();

    32   });

    33   do_register_cleanup(() => gHttpServer.stop(() => {}));

    35   Services.prefs.setBoolPref("experiments.enabled", true);

    36   Services.prefs.setCharPref("experiments.manifest.uri",

    37                              httpRoot + "manifests/handler");

    38   Services.prefs.setBoolPref("experiments.logging.dump", true);

    39   Services.prefs.setCharPref("experiments.logging.level", "Trace");

    40   disableCertificateChecks();

    41 });

    43 add_task(function* test_provider_basic() {

    44   let e = Experiments.instance();

    46   let provider = new Experiments.PreviousExperimentProvider(e);

    47   e._setPreviousExperimentsProvider(provider);

    49   let deferred = Promise.defer();

    50   provider.getAddonsByTypes(["experiment"], (addons) => {

    51     deferred.resolve(addons);

    52   });

    53   let addons = yield deferred.promise;

    54   Assert.ok(Array.isArray(addons), "getAddonsByTypes returns an Array.");

    55   Assert.equal(addons.length, 0, "No previous add-ons returned.");

    57   gManifestObject = {

    58     version: 1,

    59     experiments: [

    60       {

    61         id: EXPERIMENT1_ID,

    62         xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,

    63         xpiHash: EXPERIMENT1_XPI_SHA1,

    64         startTime: Date.now() / 1000 - 60,

    65         endTime: Date.now() / 1000 + 60,

    66         maxActiveSeconds: 60,

    67         appName: ["XPCShell"],

    68         channel: [e._policy.updatechannel()],

    69       },

    70     ],

    71   };

    73   yield e.updateManifest();

    75   deferred = Promise.defer();

    76   provider.getAddonsByTypes(["experiment"], (addons) => {

    77     deferred.resolve(addons);

    78   });

    79   addons = yield deferred.promise;

    80   Assert.equal(addons.length, 0, "Still no previous experiment.");

    82   let experiments = yield e.getExperiments();

    83   Assert.equal(experiments.length, 1, "1 experiment present.");

    84   Assert.ok(experiments[0].active, "It is active.");

    86   // Deactivate it.

    87   defineNow(e._policy, new Date(gManifestObject.experiments[0].endTime * 1000 + 1000));

    88   yield e.updateManifest();

    90   experiments = yield e.getExperiments();

    91   Assert.equal(experiments.length, 1, "1 experiment present.");

    92   Assert.equal(experiments[0].active, false, "It isn't active.");

    94   deferred = Promise.defer();

    95   provider.getAddonsByTypes(["experiment"], (addons) => {

    96     deferred.resolve(addons);

    97   });

    98   addons = yield deferred.promise;

    99   Assert.equal(addons.length, 1, "1 previous add-on known.");

   100   Assert.equal(addons[0].id, EXPERIMENT1_ID, "ID matches expected.");

   102   deferred = Promise.defer();

   103   provider.getAddonByID(EXPERIMENT1_ID, (addon) => {

   104     deferred.resolve(addon);

   105   });

   106   let addon = yield deferred.promise;

   107   Assert.ok(addon, "We got an add-on from its ID.");

   108   Assert.equal(addon.id, EXPERIMENT1_ID, "ID matches expected.");

   109   Assert.ok(addon.appDisabled, "Add-on is a previous experiment.");

   110   Assert.ok(addon.userDisabled, "Add-on is disabled.");

   111   Assert.equal(addon.type, "experiment", "Add-on is an experiment.");

   112   Assert.equal(addon.isActive, false, "Add-on is not active.");

   113   Assert.equal(addon.permissions, 0, "Add-on has no permissions.");

   115   deferred = Promise.defer();

   116   AddonManager.getAddonsByTypes(["experiment"], (addons) => {

   117     deferred.resolve(addons);

   118   });

   119   addons = yield deferred.promise;

   120   Assert.equal(addons.length, 1, "Got 1 experiment from add-on manager.");

   121   Assert.equal(addons[0].id, EXPERIMENT1_ID, "ID matches expected.");

   122   Assert.ok(addons[0].appDisabled, "It is a previous experiment add-on.");

   123 });

   125 add_task(function* test_active_and_previous() {

   126   // Building on the previous test, activate experiment 2.

   127   let e = Experiments.instance();

   128   let provider = new Experiments.PreviousExperimentProvider(e);

   129   e._setPreviousExperimentsProvider(provider);

   131   gManifestObject = {

   132     version: 1,

   133     experiments: [

   134       {

   135         id: EXPERIMENT2_ID,

   136         xpiURL: gDataRoot + EXPERIMENT2_XPI_NAME,

   137         xpiHash: EXPERIMENT2_XPI_SHA1,

   138         startTime: Date.now() / 1000 - 60,

   139         endTime: Date.now() / 1000 + 60,

   140         maxActiveSeconds: 60,

   141         appName: ["XPCShell"],

   142         channel: [e._policy.updatechannel()],

   143       },

   144     ],

   145   };

   147   defineNow(e._policy, new Date());

   148   yield e.updateManifest();

   150   let experiments = yield e.getExperiments();

   151   Assert.equal(experiments.length, 2, "2 experiments known.");

   153   let deferred = Promise.defer();

   154   provider.getAddonsByTypes(["experiment"], (addons) => {

   155     deferred.resolve(addons);

   156   });

   157   let addons = yield deferred.promise;

   158   Assert.equal(addons.length, 1, "1 previous experiment.");

   160   deferred = Promise.defer();

   161   AddonManager.getAddonsByTypes(["experiment"], (addons) => {

   162     deferred.resolve(addons);

   163   });

   164   addons = yield deferred.promise;

   165   Assert.equal(addons.length, 2, "2 experiment add-ons known.");

   167   for (let addon of addons) {

   168     if (addon.id == EXPERIMENT1_ID) {

   169       Assert.equal(addon.isActive, false, "Add-on is not active.");

   170       Assert.ok(addon.appDisabled, "Should be a previous experiment.");

   171     }

   172     else if (addon.id == EXPERIMENT2_ID) {

   173       Assert.ok(addon.isActive, "Add-on is active.");

   174       Assert.ok(!addon.appDisabled, "Should not be a previous experiment.");

   175     }

   176     else {

   177       throw new Error("Unexpected add-on ID: " + addon.id);

   178     }

   179   }

   180 });

The Tor Browser / file revision