tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_extension_storage_engine_kinto.js (4006B)

      1 /* Any copyright is dedicated to the Public Domain.
      2 * http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 "use strict";
      5 
      6 Services.prefs.setBoolPref("webextensions.storage.sync.kinto", true);
      7 
      8 const { ExtensionStorageEngineKinto: ExtensionStorageEngine } =
      9  ChromeUtils.importESModule(
     10    "resource://services-sync/engines/extension-storage.sys.mjs"
     11  );
     12 const { Service } = ChromeUtils.importESModule(
     13  "resource://services-sync/service.sys.mjs"
     14 );
     15 const { extensionStorageSyncKinto: extensionStorageSync } =
     16  ChromeUtils.importESModule(
     17    "resource://gre/modules/ExtensionStorageSyncKinto.sys.mjs"
     18  );
     19 
     20 let engine;
     21 
     22 function mock(options) {
     23  let calls = [];
     24  let ret = function () {
     25    calls.push(arguments);
     26    return options.returns;
     27  };
     28  let proto = {
     29    get calls() {
     30      return calls;
     31    },
     32  };
     33  Object.setPrototypeOf(proto, Function.prototype);
     34  Object.setPrototypeOf(ret, proto);
     35  return ret;
     36 }
     37 
     38 function setSkipChance(v) {
     39  Services.prefs.setIntPref(
     40    "services.sync.extension-storage.skipPercentageChance",
     41    v
     42  );
     43 }
     44 
     45 add_task(async function setup() {
     46  await Service.engineManager.register(ExtensionStorageEngine);
     47  engine = Service.engineManager.get("extension-storage");
     48  do_get_profile(); // so we can use FxAccounts
     49  loadWebExtensionTestFunctions();
     50  setSkipChance(0);
     51 });
     52 
     53 add_task(async function test_calling_sync_calls__sync() {
     54  let oldSync = ExtensionStorageEngine.prototype._sync;
     55  let syncMock = (ExtensionStorageEngine.prototype._sync = mock({
     56    returns: true,
     57  }));
     58  try {
     59    // I wanted to call the main sync entry point for the entire
     60    // package, but that fails because it tries to sync ClientEngine
     61    // first, which fails.
     62    await engine.sync();
     63  } finally {
     64    ExtensionStorageEngine.prototype._sync = oldSync;
     65  }
     66  equal(syncMock.calls.length, 1);
     67 });
     68 
     69 add_task(async function test_sync_skip() {
     70  try {
     71    // Do a few times to ensure we aren't getting "lucky" WRT Math.random()
     72    for (let i = 0; i < 10; ++i) {
     73      setSkipChance(100);
     74      engine._tracker._score = 0;
     75      ok(
     76        !engine.shouldSkipSync("user"),
     77        "Should allow explicitly requested syncs"
     78      );
     79      ok(!engine.shouldSkipSync("startup"), "Should allow startup syncs");
     80      ok(
     81        engine.shouldSkipSync("schedule"),
     82        "Should skip scheduled syncs if skipProbability is 100"
     83      );
     84      engine._tracker._score = MULTI_DEVICE_THRESHOLD;
     85      ok(
     86        !engine.shouldSkipSync("schedule"),
     87        "should allow scheduled syncs if tracker score is high"
     88      );
     89      engine._tracker._score = 0;
     90      setSkipChance(0);
     91      ok(
     92        !engine.shouldSkipSync("schedule"),
     93        "Should allow scheduled syncs if probability is 0"
     94      );
     95    }
     96  } finally {
     97    engine._tracker._score = 0;
     98    setSkipChance(0);
     99  }
    100 });
    101 
    102 add_task(async function test_calling_wipeClient_calls_clearAll() {
    103  let oldClearAll = extensionStorageSync.clearAll;
    104  let clearMock = (extensionStorageSync.clearAll = mock({
    105    returns: Promise.resolve(),
    106  }));
    107  try {
    108    await engine.wipeClient();
    109  } finally {
    110    extensionStorageSync.clearAll = oldClearAll;
    111  }
    112  equal(clearMock.calls.length, 1);
    113 });
    114 
    115 add_task(async function test_calling_sync_calls_ext_storage_sync() {
    116  const extension = { id: "my-extension" };
    117  let oldSync = extensionStorageSync.syncAll;
    118  let syncMock = (extensionStorageSync.syncAll = mock({
    119    returns: Promise.resolve(),
    120  }));
    121  try {
    122    await withContext(async function (context) {
    123      // Set something so that everyone knows that we're using storage.sync
    124      await extensionStorageSync.set(extension, { a: "b" }, context);
    125      let ping = await sync_engine_and_validate_telem(engine, false);
    126      Assert.ok(ping.engines.find(e => e.name == "extension-storage"));
    127      Assert.equal(
    128        ping.engines.find(e => e.name == "rust-webext-storage"),
    129        null
    130      );
    131    });
    132  } finally {
    133    extensionStorageSync.syncAll = oldSync;
    134  }
    135  Assert.greaterOrEqual(syncMock.calls.length, 1);
    136 });