dom/quota/test/xpcshell/common/head.js

   1 /**
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/publicdomain/zero/1.0/
   4  */
   5
   6 const NS_OK = Cr.NS_OK;
   7 const NS_ERROR_FAILURE = Cr.NS_ERROR_FAILURE;
   8 const NS_ERROR_UNEXPECTED = Cr.NS_ERROR_UNEXPECTED;
   9 const NS_ERROR_FILE_NO_DEVICE_SPACE = Cr.NS_ERROR_FILE_NO_DEVICE_SPACE;
  10
  11 const loggingEnabled = false;
  12
  13 var testGenerator;
  14
  15 loadScript("dom/quota/test/common/xpcshell.js");
  16
  17 function log(msg) {
  18   if (loggingEnabled) {
  19     info(msg);
  20   }
  21 }
  22
  23 function is(a, b, msg) {
  24   Assert.equal(a, b, msg);
  25 }
  26
  27 function ok(cond, msg) {
  28   Assert.ok(!!cond, msg);
  29 }
  30
  31 function todo(cond, msg) {
  32   todo_check_true(cond);
  33 }
  34
  35 function run_test() {
  36   runTest();
  37 }
  38
  39 if (!this.runTest) {
  40   this.runTest = function () {
  41     do_get_profile();
  42
  43     enableStorageTesting();
  44     enableTesting();
  45
  46     // In order to support converting tests to using async functions from using
  47     // generator functions, we detect async functions by checking the name of
  48     // function's constructor.
  49     Assert.ok(
  50       typeof testSteps === "function",
  51       "There should be a testSteps function"
  52     );
  53     if (testSteps.constructor.name === "AsyncFunction") {
  54       // Do run our existing cleanup function that would normally be called by
  55       // the generator's call to finishTest().
  56       registerCleanupFunction(function () {
  57         resetStorageTesting();
  58         resetTesting();
  59       });
  60
  61       add_task(testSteps);
  62
  63       // Since we defined run_test, we must invoke run_next_test() to start the
  64       // async test.
  65       run_next_test();
  66     } else {
  67       Assert.ok(
  68         testSteps.constructor.name === "GeneratorFunction",
  69         "Unsupported function type"
  70       );
  71
  72       do_test_pending();
  73
  74       testGenerator = testSteps();
  75       testGenerator.next();
  76     }
  77   };
  78 }
  79
  80 function finishTest() {
  81   resetStorageTesting();
  82   resetTesting();
  83
  84   executeSoon(function () {
  85     do_test_finished();
  86   });
  87 }
  88
  89 function grabArgAndContinueHandler(arg) {
  90   testGenerator.next(arg);
  91 }
  92
  93 function continueToNextStep() {
  94   executeSoon(function () {
  95     testGenerator.next();
  96   });
  97 }
  98
  99 function continueToNextStepSync() {
 100   testGenerator.next();
 101 }
 102
 103 function enableTesting() {
 104   SpecialPowers.setBoolPref(
 105     "dom.storage.enable_unsupported_legacy_implementation",
 106     false
 107   );
 108 }
 109
 110 function resetTesting() {
 111   SpecialPowers.clearUserPref(
 112     "dom.storage.enable_unsupported_legacy_implementation"
 113   );
 114 }
 115
 116 function setGlobalLimit(globalLimit) {
 117   SpecialPowers.setIntPref(
 118     "dom.quotaManager.temporaryStorage.fixedLimit",
 119     globalLimit
 120   );
 121 }
 122
 123 function resetGlobalLimit() {
 124   SpecialPowers.clearUserPref("dom.quotaManager.temporaryStorage.fixedLimit");
 125 }
 126
 127 function storageInitialized(callback) {
 128   let request = SpecialPowers._getQuotaManager().storageInitialized();
 129   request.callback = callback;
 130
 131   return request;
 132 }
 133
 134 function persistentStorageInitialized(callback) {
 135   let request = SpecialPowers._getQuotaManager().persistentStorageInitialized();
 136   request.callback = callback;
 137
 138   return request;
 139 }
 140
 141 function temporaryStorageInitialized(callback) {
 142   let request = SpecialPowers._getQuotaManager().temporaryStorageInitialized();
 143   request.callback = callback;
 144
 145   return request;
 146 }
 147
 148 function persistentOriginInitialized(principal, callback) {
 149   let request =
 150     SpecialPowers._getQuotaManager().persistentOriginInitialized(principal);
 151   request.callback = callback;
 152
 153   return request;
 154 }
 155
 156 function temporaryOriginInitialized(persistence, principal, callback) {
 157   let request = SpecialPowers._getQuotaManager().temporaryOriginInitialized(
 158     persistence,
 159     principal
 160   );
 161   request.callback = callback;
 162
 163   return request;
 164 }
 165
 166 function init(callback) {
 167   let request = SpecialPowers._getQuotaManager().init();
 168   request.callback = callback;
 169
 170   return request;
 171 }
 172
 173 function initializePersistentStorage(callback) {
 174   let request = SpecialPowers._getQuotaManager().initializePersistentStorage();
 175   request.callback = callback;
 176
 177   return request;
 178 }
 179
 180 function initTemporaryStorage(callback) {
 181   let request = SpecialPowers._getQuotaManager().initTemporaryStorage();
 182   request.callback = callback;
 183
 184   return request;
 185 }
 186
 187 function initPersistentOrigin(principal, callback) {
 188   let request =
 189     SpecialPowers._getQuotaManager().initializePersistentOrigin(principal);
 190   request.callback = callback;
 191
 192   return request;
 193 }
 194
 195 function initTemporaryOrigin(
 196   persistence,
 197   principal,
 198   createIfNonExistent = true,
 199   callback
 200 ) {
 201   let request = SpecialPowers._getQuotaManager().initializeTemporaryOrigin(
 202     persistence,
 203     principal,
 204     createIfNonExistent
 205   );
 206   request.callback = callback;
 207
 208   return request;
 209 }
 210
 211 function initPersistentClient(principal, client, callback) {
 212   let request = SpecialPowers._getQuotaManager().initializePersistentClient(
 213     principal,
 214     client
 215   );
 216   request.callback = callback;
 217
 218   return request;
 219 }
 220
 221 function initTemporaryClient(persistence, principal, client, callback) {
 222   let request = SpecialPowers._getQuotaManager().initializeTemporaryClient(
 223     persistence,
 224     principal,
 225     client
 226   );
 227   request.callback = callback;
 228
 229   return request;
 230 }
 231
 232 function getFullOriginMetadata(persistence, principal, callback) {
 233   const request = SpecialPowers._getQuotaManager().getFullOriginMetadata(
 234     persistence,
 235     principal
 236   );
 237   request.callback = callback;
 238
 239   return request;
 240 }
 241
 242 function clearClient(principal, client, persistence, callback) {
 243   let request = SpecialPowers._getQuotaManager().clearStoragesForClient(
 244     principal,
 245     client,
 246     persistence
 247   );
 248   request.callback = callback;
 249
 250   return request;
 251 }
 252
 253 function clearOrigin(principal, persistence, callback) {
 254   let request = SpecialPowers._getQuotaManager().clearStoragesForPrincipal(
 255     principal,
 256     persistence
 257   );
 258   request.callback = callback;
 259
 260   return request;
 261 }
 262
 263 function clearOriginsByPrefix(principal, persistence, callback) {
 264   let request = SpecialPowers._getQuotaManager().clearStoragesForOriginPrefix(
 265     principal,
 266     persistence
 267   );
 268   request.callback = callback;
 269
 270   return request;
 271 }
 272
 273 function clearPrivateBrowsing(callback) {
 274   let request =
 275     SpecialPowers._getQuotaManager().clearStoragesForPrivateBrowsing();
 276   request.callback = callback;
 277
 278   return request;
 279 }
 280
 281 function resetClient(principal, client) {
 282   let request = Services.qms.resetStoragesForClient(
 283     principal,
 284     client,
 285     "default"
 286   );
 287
 288   return request;
 289 }
 290
 291 function persist(principal, callback) {
 292   let request = SpecialPowers._getQuotaManager().persist(principal);
 293   request.callback = callback;
 294
 295   return request;
 296 }
 297
 298 function persisted(principal, callback) {
 299   let request = SpecialPowers._getQuotaManager().persisted(principal);
 300   request.callback = callback;
 301
 302   return request;
 303 }
 304
 305 function estimateOrigin(principal, callback) {
 306   let request = SpecialPowers._getQuotaManager().estimate(principal);
 307   request.callback = callback;
 308
 309   return request;
 310 }
 311
 312 function listOrigins(callback) {
 313   let request = SpecialPowers._getQuotaManager().listOrigins(callback);
 314   request.callback = callback;
 315
 316   return request;
 317 }
 318
 319 function getPersistedFromMetadata(readBuffer) {
 320   const persistedPosition = 8; // Persisted state is stored in the 9th byte
 321   let view =
 322     readBuffer instanceof Uint8Array ? readBuffer : new Uint8Array(readBuffer);
 323
 324   return !!view[persistedPosition];
 325 }
 326
 327 function grabResultAndContinueHandler(request) {
 328   testGenerator.next(request.result);
 329 }
 330
 331 function grabUsageAndContinueHandler(request) {
 332   testGenerator.next(request.result.usage);
 333 }
 334
 335 function getUsage(usageHandler, getAll) {
 336   let request = SpecialPowers._getQuotaManager().getUsage(usageHandler, getAll);
 337
 338   return request;
 339 }
 340
 341 function getOriginUsage(principal) {
 342   let request = Services.qms.getUsageForPrincipal(principal, function () {});
 343
 344   return request;
 345 }
 346
 347 function getCachedOriginUsage(principal) {
 348   let request = Services.qms.getCachedUsageForPrincipal(
 349     principal,
 350     function () {}
 351   );
 352
 353   return request;
 354 }
 355
 356 function getCachedOriginUsage(principal) {
 357   let request = Services.qms.getCachedUsageForPrincipal(principal);
 358
 359   return request;
 360 }
 361
 362 function getCurrentUsage(usageHandler) {
 363   let principal = Cc["@mozilla.org/systemprincipal;1"].createInstance(
 364     Ci.nsIPrincipal
 365   );
 366   let request = SpecialPowers._getQuotaManager().getUsageForPrincipal(
 367     principal,
 368     usageHandler
 369   );
 370
 371   return request;
 372 }
 373
 374 function getPrincipal(url, attr = {}) {
 375   let uri = Cc["@mozilla.org/network/io-service;1"]
 376     .getService(Ci.nsIIOService)
 377     .newURI(url);
 378   let ssm = Cc["@mozilla.org/scriptsecuritymanager;1"].getService(
 379     Ci.nsIScriptSecurityManager
 380   );
 381   return ssm.createContentPrincipal(uri, attr);
 382 }
 383
 384 var SpecialPowers = {
 385   getBoolPref(prefName) {
 386     return this._getPrefs().getBoolPref(prefName);
 387   },
 388
 389   setBoolPref(prefName, value) {
 390     this._getPrefs().setBoolPref(prefName, value);
 391   },
 392
 393   setIntPref(prefName, value) {
 394     this._getPrefs().setIntPref(prefName, value);
 395   },
 396
 397   clearUserPref(prefName) {
 398     this._getPrefs().clearUserPref(prefName);
 399   },
 400
 401   _getPrefs() {
 402     let prefService = Cc["@mozilla.org/preferences-service;1"].getService(
 403       Ci.nsIPrefService
 404     );
 405     return prefService.getBranch(null);
 406   },
 407
 408   _getQuotaManager() {
 409     return Cc["@mozilla.org/dom/quota-manager-service;1"].getService(
 410       Ci.nsIQuotaManagerService
 411     );
 412   },
 413 };
 414
 415 function installPackages(packageRelativePaths) {
 416   if (packageRelativePaths.length != 2) {
 417     throw new Error("Unsupported number of package relative paths");
 418   }
 419
 420   for (const packageRelativePath of packageRelativePaths) {
 421     installPackage(packageRelativePath);
 422   }
 423 }
 424
 425 // Take current storage structure on disk and compare it with the expected
 426 // structure. The expected structure is defined in JSON and consists of a per
 427 // test package definition and a shared package definition. The shared package
 428 // definition should contain unknown stuff which needs to be properly handled
 429 // in all situations.
 430 function verifyStorage(packageDefinitionRelativePaths, key, sharedKey) {
 431   if (packageDefinitionRelativePaths.length != 2) {
 432     throw new Error("Unsupported number of package definition relative paths");
 433   }
 434
 435   function verifyEntries(entries, name, indent = "") {
 436     log(`${indent}Verifying ${name} entries`);
 437
 438     indent += "  ";
 439
 440     for (const entry of entries) {
 441       const maybeName = entry.name;
 442
 443       log(`${indent}Verifying entry ${maybeName}`);
 444
 445       let hasName = false;
 446       let hasDir = false;
 447       let hasEntries = false;
 448
 449       for (const property in entry) {
 450         switch (property) {
 451           case "note":
 452           case "todo":
 453             break;
 454
 455           case "name":
 456             hasName = true;
 457             break;
 458
 459           case "dir":
 460             hasDir = true;
 461             break;
 462
 463           case "entries":
 464             hasEntries = true;
 465             break;
 466
 467           default:
 468             throw new Error(`Unknown property ${property}`);
 469         }
 470       }
 471
 472       if (!hasName) {
 473         throw new Error("An entry must have the name property");
 474       }
 475
 476       if (!hasDir) {
 477         throw new Error("An entry must have the dir property");
 478       }
 479
 480       if (hasEntries && !entry.dir) {
 481         throw new Error("An entry can't have entries if it's not a directory");
 482       }
 483
 484       if (hasEntries) {
 485         verifyEntries(entry.entries, entry.name, indent);
 486       }
 487     }
 488   }
 489
 490   function getCurrentEntries() {
 491     log("Getting current entries");
 492
 493     function getEntryForFile(file) {
 494       let entry = {
 495         name: file.leafName,
 496         dir: file.isDirectory(),
 497       };
 498
 499       if (file.isDirectory()) {
 500         const enumerator = file.directoryEntries;
 501         let nextFile;
 502         while ((nextFile = enumerator.nextFile)) {
 503           if (!entry.entries) {
 504             entry.entries = [];
 505           }
 506           entry.entries.push(getEntryForFile(nextFile));
 507         }
 508       }
 509
 510       return entry;
 511     }
 512
 513     let entries = [];
 514
 515     let file = getRelativeFile("indexedDB");
 516     if (file.exists()) {
 517       entries.push(getEntryForFile(file));
 518     }
 519
 520     file = getRelativeFile("storage");
 521     if (file.exists()) {
 522       entries.push(getEntryForFile(file));
 523     }
 524
 525     file = getRelativeFile("storage.sqlite");
 526     if (file.exists()) {
 527       entries.push(getEntryForFile(file));
 528     }
 529
 530     verifyEntries(entries, "current");
 531
 532     return entries;
 533   }
 534
 535   function getEntriesFromPackageDefinition(
 536     packageDefinitionRelativePath,
 537     lookupKey
 538   ) {
 539     log(`Getting ${lookupKey} entries from ${packageDefinitionRelativePath}`);
 540
 541     const currentDir = Services.dirsvc.get("CurWorkD", Ci.nsIFile);
 542     const file = getRelativeFile(
 543       packageDefinitionRelativePath + ".json",
 544       currentDir
 545     );
 546
 547     const fileInputStream = Cc[
 548       "@mozilla.org/network/file-input-stream;1"
 549     ].createInstance(Ci.nsIFileInputStream);
 550     fileInputStream.init(file, -1, -1, 0);
 551
 552     const scriptableInputStream = Cc[
 553       "@mozilla.org/scriptableinputstream;1"
 554     ].createInstance(Ci.nsIScriptableInputStream);
 555     scriptableInputStream.init(fileInputStream);
 556
 557     const data = scriptableInputStream.readBytes(
 558       scriptableInputStream.available()
 559     );
 560
 561     const obj = JSON.parse(data);
 562
 563     const result = obj.find(({ key: elementKey }) => elementKey == lookupKey);
 564
 565     if (!result) {
 566       throw new Error("The file doesn't contain an element for given key");
 567     }
 568
 569     if (!result.entries) {
 570       throw new Error("The element doesn't have the entries property");
 571     }
 572
 573     verifyEntries(result.entries, lookupKey);
 574
 575     return result.entries;
 576   }
 577
 578   function addSharedEntries(expectedEntries, sharedEntries, name, indent = "") {
 579     log(`${indent}Checking common ${name} entries`);
 580
 581     indent += "  ";
 582
 583     for (const sharedEntry of sharedEntries) {
 584       const expectedEntry = expectedEntries.find(
 585         ({ name: elementName }) => elementName == sharedEntry.name
 586       );
 587
 588       if (expectedEntry) {
 589         log(`${indent}Checking common entry ${sharedEntry.name}`);
 590
 591         if (!expectedEntry.dir || !sharedEntry.dir) {
 592           throw new Error("A common entry must be a directory");
 593         }
 594
 595         if (!expectedEntry.entries && !sharedEntry.entries) {
 596           throw new Error("A common entry must not be a leaf");
 597         }
 598
 599         if (sharedEntry.entries) {
 600           if (!expectedEntry.entries) {
 601             expectedEntry.entries = [];
 602           }
 603
 604           addSharedEntries(
 605             expectedEntry.entries,
 606             sharedEntry.entries,
 607             sharedEntry.name,
 608             indent
 609           );
 610         }
 611       } else {
 612         log(`${indent}Adding entry ${sharedEntry.name}`);
 613         expectedEntries.push(sharedEntry);
 614       }
 615     }
 616   }
 617
 618   function compareEntries(currentEntries, expectedEntries, name, indent = "") {
 619     log(`${indent}Comparing ${name} entries`);
 620
 621     indent += "  ";
 622
 623     if (currentEntries.length != expectedEntries.length) {
 624       throw new Error("Entries must have the same length");
 625     }
 626
 627     for (const currentEntry of currentEntries) {
 628       log(`${indent}Comparing entry ${currentEntry.name}`);
 629
 630       const expectedEntry = expectedEntries.find(
 631         ({ name: elementName }) => elementName == currentEntry.name
 632       );
 633
 634       if (!expectedEntry) {
 635         throw new Error("Cannot find a matching entry");
 636       }
 637
 638       if (expectedEntry.dir != currentEntry.dir) {
 639         throw new Error("The dir property doesn't match");
 640       }
 641
 642       if (
 643         (expectedEntry.entries && !currentEntry.entries) ||
 644         (!expectedEntry.entries && currentEntry.entries)
 645       ) {
 646         throw new Error("The entries property doesn't match");
 647       }
 648
 649       if (expectedEntry.entries) {
 650         compareEntries(
 651           currentEntry.entries,
 652           expectedEntry.entries,
 653           currentEntry.name,
 654           indent
 655         );
 656       }
 657     }
 658   }
 659
 660   const currentEntries = getCurrentEntries();
 661
 662   log("Stringified current entries: " + JSON.stringify(currentEntries));
 663
 664   const expectedEntries = getEntriesFromPackageDefinition(
 665     packageDefinitionRelativePaths[0],
 666     key
 667   );
 668   const sharedEntries = getEntriesFromPackageDefinition(
 669     packageDefinitionRelativePaths[1],
 670     sharedKey ? sharedKey : key
 671   );
 672
 673   addSharedEntries(expectedEntries, sharedEntries, key);
 674
 675   log("Stringified expected entries: " + JSON.stringify(expectedEntries));
 676
 677   compareEntries(currentEntries, expectedEntries, key);
 678 }
 679
 680 async function verifyInitializationStatus(
 681   expectStorageIsInitialized,
 682   expectPersistentStorageIsInitialized,
 683   expectTemporaryStorageIsInitialized
 684 ) {
 685   if (!expectStorageIsInitialized && expectPersistentStorageIsInitialized) {
 686     throw new Error("Invalid expectation");
 687   }
 688
 689   if (!expectStorageIsInitialized && expectTemporaryStorageIsInitialized) {
 690     throw new Error("Invalid expectation");
 691   }
 692
 693   let request = storageInitialized();
 694   await requestFinished(request);
 695
 696   const storageIsInitialized = request.result;
 697
 698   request = persistentStorageInitialized();
 699   await requestFinished(request);
 700
 701   const persistentStorageIsInitialized = request.result;
 702
 703   request = temporaryStorageInitialized();
 704   await requestFinished(request);
 705
 706   const temporaryStorageIsInitialized = request.result;
 707
 708   ok(
 709     !(!storageIsInitialized && persistentStorageIsInitialized),
 710     "Initialization status is consistent"
 711   );
 712
 713   ok(
 714     !(!storageIsInitialized && temporaryStorageIsInitialized),
 715     "Initialization status is consistent"
 716   );
 717
 718   if (expectStorageIsInitialized) {
 719     ok(storageIsInitialized, "Storage is initialized");
 720   } else {
 721     ok(!storageIsInitialized, "Storage is not initialized");
 722   }
 723
 724   if (expectPersistentStorageIsInitialized) {
 725     ok(persistentStorageIsInitialized, "Persistent storage is initialized");
 726   } else {
 727     ok(
 728       !persistentStorageIsInitialized,
 729       "Persistent storage is not initialized"
 730     );
 731   }
 732
 733   if (expectTemporaryStorageIsInitialized) {
 734     ok(temporaryStorageIsInitialized, "Temporary storage is initialized");
 735   } else {
 736     ok(!temporaryStorageIsInitialized, "Temporary storage is not initialized");
 737   }
 738 }