dom/quota/test/xpcshell/make_unknownFiles.js

   1 /**
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/publicdomain/zero/1.0/
   4  */
   5
   6 loadScript("dom/quota/test/common/file.js");
   7
   8 async function testSteps() {
   9   const principal = getPrincipal("http://example.com");
  10
  11   const repoRelativePath = "storage/default";
  12   const originRelativePath = `${repoRelativePath}/http+++example.com`;
  13
  14   let unknownFileCounter = 1;
  15   let unknownDirCounter = 1;
  16
  17   function createUnknownFileIn(dirRelativePath, recursive) {
  18     const dir = getRelativeFile(dirRelativePath);
  19
  20     let file = dir.clone();
  21     file.append("foo" + unknownFileCounter + ".bar");
  22
  23     const ostream = Cc[
  24       "@mozilla.org/network/file-output-stream;1"
  25     ].createInstance(Ci.nsIFileOutputStream);
  26
  27     ostream.init(file, -1, parseInt("0644", 8), 0);
  28
  29     ostream.write("x".repeat(unknownFileCounter), unknownFileCounter);
  30
  31     ostream.close();
  32
  33     unknownFileCounter++;
  34
  35     if (recursive) {
  36       const entries = dir.directoryEntries;
  37       while ((file = entries.nextFile)) {
  38         if (file.isDirectory()) {
  39           createUnknownFileIn(dirRelativePath + "/" + file.leafName);
  40         }
  41       }
  42     }
  43   }
  44
  45   function createUnknownDirectoryIn(dirRelativePath) {
  46     createUnknownFileIn(dirRelativePath + "/foo" + unknownDirCounter++);
  47   }
  48
  49   // storage.sqlite and storage/ls-archive.sqlite
  50   {
  51     const request = init();
  52     await requestFinished(request);
  53   }
  54
  55   // Unknown file in the repository
  56   {
  57     createUnknownFileIn(repoRelativePath);
  58   }
  59
  60   // Unknown file and unknown directory in the origin directory
  61   {
  62     let request = init();
  63     await requestFinished(request);
  64
  65     request = initTemporaryStorage();
  66     await requestFinished(request);
  67
  68     request = initTemporaryOrigin("default", principal);
  69     await requestFinished(request);
  70
  71     Assert.strictEqual(
  72       request.result,
  73       true,
  74       "The origin directory was created"
  75     );
  76
  77     createUnknownFileIn(originRelativePath);
  78     createUnknownDirectoryIn(originRelativePath);
  79   }
  80
  81   // Unknown files in idb client directory and its subdirectories and unknown
  82   // directory in .files directory
  83   {
  84     const request = indexedDB.openForPrincipal(principal, "myIndexedDB");
  85     await openDBRequestUpgradeNeeded(request);
  86
  87     const database = request.result;
  88
  89     const objectStore = database.createObjectStore("Blobs", {});
  90
  91     objectStore.add(getNullBlob(200), 42);
  92
  93     await openDBRequestSucceeded(request);
  94
  95     database.close();
  96
  97     createUnknownFileIn(`${originRelativePath}/idb`);
  98     createUnknownFileIn(
  99       `${originRelativePath}/idb/2320029346mByDIdnedxe.files`
 100     );
 101     createUnknownDirectoryIn(
 102       `${originRelativePath}/idb/2320029346mByDIdnedxe.files`
 103     );
 104     createUnknownFileIn(
 105       `${originRelativePath}/idb/2320029346mByDIdnedxe.files/journals`
 106     );
 107   }
 108
 109   // Unknown files in cache client directory and its subdirectories
 110   {
 111     async function sandboxScript() {
 112       const cache = await caches.open("myCache");
 113       const request = new Request("http://example.com/index.html");
 114       const response = new Response("hello world");
 115       await cache.put(request, response);
 116     }
 117
 118     const sandbox = new Cu.Sandbox(principal, {
 119       wantGlobalProperties: ["caches", "fetch"],
 120     });
 121
 122     const promise = new Promise(function (resolve, reject) {
 123       sandbox.resolve = resolve;
 124       sandbox.reject = reject;
 125     });
 126
 127     Cu.evalInSandbox(
 128       sandboxScript.toSource() + " sandboxScript().then(resolve, reject);",
 129       sandbox
 130     );
 131     await promise;
 132
 133     createUnknownFileIn(`${originRelativePath}/cache`);
 134     createUnknownFileIn(
 135       `${originRelativePath}/cache/morgue`,
 136       /* recursive */ true
 137     );
 138   }
 139
 140   // Unknown file and unknown directory in sdb client directory
 141   {
 142     const database = getSimpleDatabase(principal);
 143
 144     let request = database.open("mySimpleDB");
 145     await requestFinished(request);
 146
 147     request = database.write(getBuffer(100));
 148     await requestFinished(request);
 149
 150     request = database.close();
 151     await requestFinished(request);
 152
 153     createUnknownFileIn(`${originRelativePath}/sdb`);
 154     createUnknownDirectoryIn(`${originRelativePath}/sdb`);
 155   }
 156
 157   // Unknown file and unknown directory in ls client directory
 158   {
 159     Services.prefs.setBoolPref("dom.storage.testing", true);
 160     Services.prefs.setBoolPref("dom.storage.client_validation", false);
 161
 162     const storage = Services.domStorageManager.createStorage(
 163       null,
 164       principal,
 165       principal,
 166       ""
 167     );
 168
 169     storage.setItem("foo", "bar");
 170
 171     storage.close();
 172
 173     createUnknownFileIn(`${originRelativePath}/ls`);
 174     createUnknownDirectoryIn(`${originRelativePath}/ls`);
 175   }
 176 }