dom/quota/test/mochitest/helpers.js

   1 /**
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/publicdomain/zero/1.0/
   4  */
   5
   6 // The path to the top level directory.
   7 const depth = "../../../../";
   8
   9 var testGenerator;
  10 var testHarnessGenerator;
  11 var workerScriptPaths = [];
  12
  13 loadScript("dom/quota/test/common/mochitest.js");
  14
  15 function loadScript(path) {
  16   const url = new URL(depth + path, window.location.href);
  17   SpecialPowers.Services.scriptloader.loadSubScript(url.href, this);
  18 }
  19
  20 function loadWorkerScript(path) {
  21   const url = new URL(depth + path, window.location.href);
  22   workerScriptPaths.push(url.href);
  23 }
  24
  25 function* testHarnessSteps() {
  26   function nextTestHarnessStep(val) {
  27     testHarnessGenerator.next(val);
  28   }
  29
  30   info("Enabling storage testing");
  31
  32   enableStorageTesting().then(nextTestHarnessStep);
  33   yield undefined;
  34
  35   info("Pushing preferences");
  36
  37   SpecialPowers.pushPrefEnv(
  38     {
  39       set: [["dom.storageManager.prompt.testing", true]],
  40     },
  41     nextTestHarnessStep
  42   );
  43   yield undefined;
  44
  45   info("Clearing old databases");
  46
  47   clearAllDatabases(nextTestHarnessStep);
  48   yield undefined;
  49
  50   info("Running test in given scopes");
  51
  52   if (workerScriptPaths.length) {
  53     info("Running test in a worker");
  54
  55     let workerScriptBlob = new Blob(["(" + workerScript.toString() + ")();"], {
  56       type: "text/javascript",
  57     });
  58     let workerScriptURL = URL.createObjectURL(workerScriptBlob);
  59
  60     let worker = new Worker(workerScriptURL);
  61
  62     worker.onerror = function (event) {
  63       ok(false, "Worker had an error: " + event.message);
  64       worker.terminate();
  65       nextTestHarnessStep();
  66     };
  67
  68     worker.onmessage = function (event) {
  69       let message = event.data;
  70       switch (message.op) {
  71         case "ok":
  72           ok(message.condition, message.name + " - " + message.diag);
  73           break;
  74
  75         case "todo":
  76           todo(message.condition, message.name, message.diag);
  77           break;
  78
  79         case "info":
  80           info(message.msg);
  81           break;
  82
  83         case "ready":
  84           worker.postMessage({ op: "load", files: workerScriptPaths });
  85           break;
  86
  87         case "loaded":
  88           worker.postMessage({ op: "start" });
  89           break;
  90
  91         case "done":
  92           ok(true, "Worker finished");
  93           nextTestHarnessStep();
  94           break;
  95
  96         case "clearAllDatabases":
  97           clearAllDatabases(function () {
  98             worker.postMessage({ op: "clearAllDatabasesDone" });
  99           });
 100           break;
 101
 102         default:
 103           ok(
 104             false,
 105             "Received a bad message from worker: " + JSON.stringify(message)
 106           );
 107           nextTestHarnessStep();
 108       }
 109     };
 110
 111     URL.revokeObjectURL(workerScriptURL);
 112
 113     yield undefined;
 114
 115     worker.terminate();
 116     worker = null;
 117
 118     clearAllDatabases(nextTestHarnessStep);
 119     yield undefined;
 120   }
 121
 122   info("Running test in main thread");
 123
 124   // Now run the test script in the main thread.
 125   if (testSteps.constructor.name === "AsyncFunction") {
 126     SimpleTest.registerCleanupFunction(async function () {
 127       await requestFinished(clearAllDatabases());
 128     });
 129
 130     add_task(testSteps);
 131   } else {
 132     testGenerator = testSteps();
 133     testGenerator.next();
 134
 135     yield undefined;
 136   }
 137 }
 138
 139 if (!window.runTest) {
 140   window.runTest = function () {
 141     SimpleTest.waitForExplicitFinish();
 142     testHarnessGenerator = testHarnessSteps();
 143     testHarnessGenerator.next();
 144   };
 145 }
 146
 147 function finishTest() {
 148   SimpleTest.executeSoon(function () {
 149     clearAllDatabases(function () {
 150       SimpleTest.finish();
 151     });
 152   });
 153 }
 154
 155 function grabArgAndContinueHandler(arg) {
 156   testGenerator.next(arg);
 157 }
 158
 159 function continueToNextStep() {
 160   SimpleTest.executeSoon(function () {
 161     testGenerator.next();
 162   });
 163 }
 164
 165 function continueToNextStepSync() {
 166   testGenerator.next();
 167 }
 168
 169 function workerScript() {
 170   "use strict";
 171
 172   self.testGenerator = null;
 173
 174   self.repr = function (_thing_) {
 175     if (typeof _thing_ == "undefined") {
 176       return "undefined";
 177     }
 178
 179     let str;
 180
 181     try {
 182       str = _thing_ + "";
 183     } catch (e) {
 184       return "[" + typeof _thing_ + "]";
 185     }
 186
 187     if (typeof _thing_ == "function") {
 188       str = str.replace(/^\s+/, "");
 189       let idx = str.indexOf("{");
 190       if (idx != -1) {
 191         str = str.substr(0, idx) + "{...}";
 192       }
 193     }
 194
 195     return str;
 196   };
 197
 198   self.ok = function (_condition_, _name_, _diag_) {
 199     self.postMessage({
 200       op: "ok",
 201       condition: !!_condition_,
 202       name: _name_,
 203       diag: _diag_,
 204     });
 205   };
 206
 207   self.is = function (_a_, _b_, _name_) {
 208     let pass = _a_ == _b_;
 209     let diag = pass ? "" : "got " + repr(_a_) + ", expected " + repr(_b_);
 210     ok(pass, _name_, diag);
 211   };
 212
 213   self.isnot = function (_a_, _b_, _name_) {
 214     let pass = _a_ != _b_;
 215     let diag = pass ? "" : "didn't expect " + repr(_a_) + ", but got it";
 216     ok(pass, _name_, diag);
 217   };
 218
 219   self.todo = function (_condition_, _name_, _diag_) {
 220     self.postMessage({
 221       op: "todo",
 222       condition: !!_condition_,
 223       name: _name_,
 224       diag: _diag_,
 225     });
 226   };
 227
 228   self.info = function (_msg_) {
 229     self.postMessage({ op: "info", msg: _msg_ });
 230   };
 231
 232   self.executeSoon = function (_fun_) {
 233     var channel = new MessageChannel();
 234     channel.port1.postMessage("");
 235     channel.port2.onmessage = function (event) {
 236       _fun_();
 237     };
 238   };
 239
 240   self.finishTest = function () {
 241     self.postMessage({ op: "done" });
 242   };
 243
 244   self.grabArgAndContinueHandler = function (_arg_) {
 245     testGenerator.next(_arg_);
 246   };
 247
 248   self.continueToNextStep = function () {
 249     executeSoon(function () {
 250       testGenerator.next();
 251     });
 252   };
 253
 254   self.continueToNextStepSync = function () {
 255     testGenerator.next();
 256   };
 257
 258   self._clearAllDatabasesCallback = undefined;
 259   self.clearAllDatabases = function (_callback_) {
 260     self._clearAllDatabasesCallback = _callback_;
 261     self.postMessage({ op: "clearAllDatabases" });
 262   };
 263
 264   self.onerror = function (_message_, _file_, _line_) {
 265     ok(
 266       false,
 267       "Worker: uncaught exception [" +
 268         _file_ +
 269         ":" +
 270         _line_ +
 271         "]: '" +
 272         _message_ +
 273         "'"
 274     );
 275     self.finishTest();
 276     self.close();
 277     return true;
 278   };
 279
 280   self.onmessage = function (_event_) {
 281     let message = _event_.data;
 282     switch (message.op) {
 283       case "load":
 284         info("Worker: loading " + JSON.stringify(message.files));
 285         self.importScripts(message.files);
 286         self.postMessage({ op: "loaded" });
 287         break;
 288
 289       case "start":
 290         executeSoon(function () {
 291           info("Worker: starting tests");
 292           testGenerator = testSteps();
 293           testGenerator.next();
 294         });
 295         break;
 296
 297       case "clearAllDatabasesDone":
 298         info("Worker: all databases are cleared");
 299         if (self._clearAllDatabasesCallback) {
 300           self._clearAllDatabasesCallback();
 301         }
 302         break;
 303
 304       default:
 305         throw new Error(
 306           "Received a bad message from parent: " + JSON.stringify(message)
 307         );
 308     }
 309   };
 310
 311   self.postMessage({ op: "ready" });
 312 }