tor-browser

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

test_upgradeFromPersistentStorageDirectory_upgradeOriginDirectories.js (4261B)

      1 /**
      2 * Any copyright is dedicated to the Public Domain.
      3 * http://creativecommons.org/publicdomain/zero/1.0/
      4 */
      5 
      6 function* testSteps() {
      7  const origins = [
      8    {
      9      oldPath: "storage/persistent/1007+f+app+++system.gaiamobile.org",
     10      upgraded: true,
     11    },
     12 
     13    {
     14      oldPath: "storage/persistent/1007+t+https+++developer.cdn.mozilla.net",
     15      upgraded: true,
     16    },
     17 
     18    {
     19      oldPath: "storage/persistent/http+++www.mozilla.org",
     20      newPath: "storage/default/http+++www.mozilla.org",
     21      url: "http://www.mozilla.org",
     22      persistence: "default",
     23      upgraded: true,
     24    },
     25    {
     26      oldPath: "storage/persistent/http+++www.mozilla.org+8080",
     27      newPath: "storage/default/http+++www.mozilla.org+8080",
     28      url: "http://www.mozilla.org:8080",
     29      persistence: "default",
     30    },
     31  ];
     32 
     33  const metadataFileName = ".metadata";
     34 
     35  const packages = [
     36    // Storage used by FF 26-35 (storage/persistent/ directory with already
     37    // upgraded origin directories and not yet upgraded flat origin
     38    // directories).
     39    "persistentStorageDirectory_originDirectories_profile",
     40    "../persistentStorageDirectory_shared",
     41  ];
     42 
     43  clear(continueToNextStepSync);
     44  yield undefined;
     45 
     46  info("Verifying storage");
     47 
     48  verifyStorage(packages, "beforeInstall");
     49 
     50  info("Installing packages");
     51 
     52  installPackages(packages);
     53 
     54  info("Verifying storage");
     55 
     56  verifyStorage(packages, "afterInstall");
     57 
     58  info("Checking origin directories");
     59 
     60  for (const origin of origins) {
     61    let originDir = getRelativeFile(origin.oldPath);
     62    let exists = originDir.exists();
     63    ok(exists, "Origin directory does exist");
     64 
     65    let idbDir = originDir.clone();
     66    idbDir.append("idb");
     67 
     68    exists = idbDir.exists();
     69    if (origin.upgraded) {
     70      ok(exists, "idb directory does exist");
     71    } else {
     72      ok(!exists, "idb directory doesn't exist");
     73    }
     74 
     75    let metadataFile = originDir.clone();
     76    metadataFile.append(metadataFileName);
     77 
     78    exists = metadataFile.exists();
     79    if (origin.upgraded) {
     80      ok(exists, "Metadata file does exist");
     81    } else {
     82      ok(!exists, "Metadata file doesn't exist");
     83    }
     84 
     85    if (origin.newPath) {
     86      originDir = getRelativeFile(origin.newPath);
     87      exists = originDir.exists();
     88      ok(!exists, "Origin directory doesn't exist");
     89    }
     90  }
     91 
     92  info("Initializing");
     93 
     94  let request = init(continueToNextStepSync);
     95  yield undefined;
     96 
     97  Assert.equal(request.resultCode, NS_OK, "Initialization succeeded");
     98 
     99  info("Verifying storage");
    100 
    101  verifyStorage(packages, "afterInit");
    102 
    103  // TODO: Remove this block once temporary storage initialization and getting
    104  //       usage is able to ignore unknown directories.
    105  getRelativeFile("storage/default/invalid+++example.com").remove(false);
    106  getRelativeFile("storage/temporary/invalid+++example.com").remove(false);
    107 
    108  info("Checking origin directories");
    109 
    110  for (const origin of origins) {
    111    let originDir = getRelativeFile(origin.oldPath);
    112    let exists = originDir.exists();
    113    ok(!exists, "Origin directory doesn't exist");
    114 
    115    if (origin.newPath) {
    116      originDir = getRelativeFile(origin.newPath);
    117      exists = originDir.exists();
    118      ok(exists, "Origin directory does exist");
    119 
    120      let idbDir = originDir.clone();
    121      idbDir.append("idb");
    122 
    123      exists = idbDir.exists();
    124      ok(exists, "idb directory does exist");
    125 
    126      let metadataFile = originDir.clone();
    127      metadataFile.append(metadataFileName);
    128 
    129      exists = metadataFile.exists();
    130      ok(exists, "Metadata file does exist");
    131    }
    132  }
    133 
    134  info("Initializing temporary storage");
    135 
    136  request = initTemporaryStorage(continueToNextStepSync);
    137  yield undefined;
    138 
    139  Assert.equal(request.resultCode, NS_OK, "Initialization succeeded");
    140 
    141  info("Initializing origins");
    142 
    143  for (const origin of origins) {
    144    if (origin.newPath) {
    145      info("Initializing origin");
    146 
    147      let principal = getPrincipal(origin.url);
    148      request = initTemporaryOrigin(
    149        origin.persistence,
    150        principal,
    151        /* createIfNonExistent */ true,
    152        continueToNextStepSync
    153      );
    154      yield undefined;
    155 
    156      Assert.equal(request.resultCode, NS_OK, "Initialization succeeded");
    157 
    158      ok(!request.result, "Origin directory wasn't created");
    159    }
    160  }
    161 
    162  finishTest();
    163 }