Add tests for the Notification module

chrome/content/tests/synchronizer.js

 (function()
 {
   let testRunner = null;
   let server = null;
   let randomResult = 0.5;
 
-  const MILLIS_IN_SECOND = 1000;
-  const MILLIS_IN_MINUTE = 60 * MILLIS_IN_SECOND;
-  const MILLIS_IN_HOUR = 60 * MILLIS_IN_MINUTE;
-  const MILLIS_IN_DAY = 24 * MILLIS_IN_HOUR;
-
   module("Synchronizer", {
-    QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
-
     setup: function()
     {
       testRunner = this;
 
       prepareFilterComponents.call(this);
       preparePrefs.call(this);
-
-      let SynchronizerGlobal = Cu.getGlobalForObject(Synchronizer);
-      let SynchronizerModule = getModuleGlobal("synchronizer");
-      let DownloaderGlobal = Cu.getGlobalForObject(SynchronizerModule.downloader);
+      setupVirtualTime.call(this, function(wrapTimer)
+      {
+        let SynchronizerModule = getModuleGlobal("synchronizer");
+        SynchronizerModule.downloader._timer = wrapTimer(SynchronizerModule.downloader._timer);
+      }, "synchronizer", "downloader");
 
       server = new nsHttpServer();
       server.start(1234);
 
-      let currentTime = 100000 * MILLIS_IN_HOUR;
-      let startTime = currentTime;
-      let scheduledTasks = [];
-
-      // Replace Date.now() function
-      this._origNow = SynchronizerGlobal.Date.now;
-      SynchronizerGlobal.Date.now = DownloaderGlobal.Date.now = function() currentTime;
-
       // Replace Math.random() function
+      let DownloaderGlobal = Cu.getGlobalForObject(getModuleGlobal("downloader"));
       this._origRandom = DownloaderGlobal.Math.random;
       DownloaderGlobal.Math.random = function() randomResult;
-
-      // Replace global timer variable
-      let timer = {__proto__: SynchronizerModule.downloader._timer, delay: 0.1 * MILLIS_IN_HOUR};
-      let callback = timer.callback;
-      timer.handler = function() { callback.notify(timer); };
-      timer.nextExecution = currentTime + timer.delay;
-      scheduledTasks.push(timer);
-      SynchronizerModule.downloader._timer.cancel();
-      SynchronizerModule.downloader._timer = timer;
-
-      // Register observer to track outstanding requests
-      this._outstandingRequests = 0;
-      Services.obs.addObserver(this, "http-on-modify-request", true);
-      Services.obs.addObserver(this, "http-on-examine-response", true);
-
-      this.runScheduledTasks = function(maxHours, initial, skip)
-      {
-        if (typeof maxHours != "number")
-          throw new Error("Numerical parameter expected");
-        if (typeof initial != "number")
-          initial = 0;
-        if (typeof skip != "number")
-          skip = 0;
-
-        startTime = currentTime;
-        if (initial >= 0)
-        {
-          this._runScheduledTasks(initial);
-          maxHours -= initial;
-        }
-        if (skip)
-        {
-          this._skipTasks(skip);
-          maxHours -= skip;
-        }
-        this._runScheduledTasks(maxHours);
-      }
-
-      this._runScheduledTasks = function(maxHours)
-      {
-        let endTime = currentTime + maxHours * MILLIS_IN_HOUR;
-        while (true)
-        {
-          let nextTask = null;
-          for each (let task in scheduledTasks)
-          {
-            if (!nextTask || nextTask.nextExecution > task.nextExecution)
-              nextTask = task;
-          }
-          if (!nextTask || nextTask.nextExecution > endTime)
-            break;
-
-          currentTime = nextTask.nextExecution;
-          nextTask.handler();
-
-          // Let all asynchronous actions finish
-          let thread = Services.tm.currentThread;
-          let loopStartTime = Date.now();
-
-          while (this._outstandingRequests > 0 || thread.hasPendingEvents())
-          {
-            thread.processNextEvent(true);
-
-            if (Date.now() - loopStartTime > 5000)
-              throw new Error("Synchronizer stuck downloading subscriptions");
-          }
-
-          if (nextTask.type == Components.interfaces.nsITimer.TYPE_ONE_SHOT)
-            scheduledTasks = scheduledTasks.filter(function(task) task != nextTask);
-          else
-            nextTask.nextExecution = currentTime + nextTask.delay;
-        }
-
-        currentTime = endTime;
-      }
-
-      this._skipTasks = function(hours)
-      {
-        let newTasks = [];
-        currentTime += hours * MILLIS_IN_HOUR;
-        for each (let task in scheduledTasks)
-        {
-          if (task.nextExecution >= currentTime)
-            newTasks.push(task);
-          else if (task.type != Components.interfaces.nsITimer.TYPE_ONE_SHOT)
-          {
-            task.nextExecution = currentTime;
-            newTasks.push(task);
-          }
-        }
-        scheduledTasks = newTasks;
-      }
-
-      this.getTimeOffset = function() (currentTime - startTime) / MILLIS_IN_HOUR;
-
-      this.__defineGetter__("currentTime", function() currentTime);
-    },
-
-    observe: function(subject, topic, data)
-    {
-      let orig = this._outstandingRequests;
-      if (topic == "http-on-modify-request")
-        this._outstandingRequests++;
-      else if (topic == "http-on-examine-response")
-        this._outstandingRequests--;
+      randomResult = 0.5;

[Felix Dahlke, 2013/07/19 14:30:41]

As in notification.js - it looks like this is always 0.5 to begin with.

[Wladimir Palant, 2013/07/19 14:58:49]

Not really, one of the tests changes it - and this makes sure that each test can
rely on its value being 0.5 unless it changes the value explicitly.

     },
 
     teardown: function()
     {
       restoreFilterComponents.call(this);
       restorePrefs.call(this);
+      restoreVirtualTime.call(this);
 
       stop();
       server.stop(function()
       {
         server = null;
         start();
       });
 
-      if (this._origNow)
-      {
-        let SynchronizerGlobal = Cu.getGlobalForObject(Synchronizer);
-        let SynchronizerModule = getModuleGlobal("synchronizer");
-        let DownloaderGlobal = Cu.getGlobalForObject(SynchronizerModule.downloader);
-        SynchronizerGlobal.Date.now = DownloaderGlobal.Date.now = this._origNow;
-        delete this._origNow;
-      }
-
       if (this._origRandom)
       {
-        let SynchronizerModule = getModuleGlobal("synchronizer");
-        let DownloaderGlobal = Cu.getGlobalForObject(SynchronizerModule.downloader);
+        let DownloaderGlobal = Cu.getGlobalForObject(getModuleGlobal("downloader"));
         DownloaderGlobal.Math.random = this._origRandom;
         delete this._origRandom;
       }
 
       Synchronizer.init();
     }
   });
 
   function resetSubscription(subscription)
   {
     FilterStorage.updateSubscriptionFilters(subscription, []);
     subscription.lastCheck =  subscription.lastDownload =
       subscription.version = subscription.lastSuccess =
       subscription.expires = subscription.softExpiration = 0;
     subscription.title = "";
     subscription.homepage = null;
     subscription.errors = 0;
     subscription.downloadStatus = null;
     subscription.requiredVersion = null;
   }
 
   test("Downloads of one subscription", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     let requests = [];
     function handler(metadata, response)
     {
       requests.push([testRunner.getTimeOffset(), metadata.method, metadata.path]);
 
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
       let result = "[Adblock]\n! ExPiREs: 1day\nfoo\nbar";
       response.bodyOutputStream.write(result, result.length);
     }
 
     server.registerPathHandler("/subscription", handler);
 
     testRunner.runScheduledTasks(50);
     deepEqual(requests, [
       [0.1, "GET", "/subscription"],
       [24.1, "GET", "/subscription"],
       [48.1, "GET", "/subscription"],
     ], "Requests after 50 hours");
   });
 
   test("Downloads of two subscriptions", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription1 = Subscription.fromURL("http://127.0.0.1:1234/subscription1");
     FilterStorage.addSubscription(subscription1);
 
     let subscription2 = Subscription.fromURL("http://127.0.0.1:1234/subscription2");
     subscription2.expires =
       subscription2.softExpiration =
       (testRunner.currentTime + 2 * MILLIS_IN_HOUR) / MILLIS_IN_SECOND;
     FilterStorage.addSubscription(subscription2);
 
     let requests = [];
@@ skipping 17 matching lines @@
       [2.1, "GET", "/subscription2"],
       [24.1, "GET", "/subscription1"],
       [26.1, "GET", "/subscription2"],
       [48.1, "GET", "/subscription1"],
       [50.1, "GET", "/subscription2"],
     ], "Requests after 55 hours");
   });
 
   test("Download result, various subscription headers", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let test;
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     function handler(metadata, response)
     {
       response.setStatusLine("1.1", "200", "OK");
 
       // Wrong content type shouldn't matter
       response.setHeader("Content-Type", "text/xml");
@@ skipping 149 matching lines @@
       testRunner.runScheduledTasks(maxHours, test.skipAfter, test.skip);
 
       let randomAddendum = (randomResult == 0.5 ? "" : " with Math.random() returning " + randomResult);
       let skipAddendum = (typeof test.skip != "number" ? "" : " skipping " + test.skip + " hours after " + test.skipAfter + " hours");
       deepEqual(requests, test.requests, "Requests for \"" + test.expiration + "\"" + randomAddendum + skipAddendum);
     }
   });
 
   test("Checksum verification", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     let testName, subscriptionBody, expectedResult;
     let tests = [
       ["Correct checksum", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoo\nbar\n", true],
       ["Wrong checksum", "[Adblock]\n! Checksum: wrongggny6Fn24b7JHsq/A\nfoo\nbar\n", false],
       ["Empty lines ignored", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\n\nfoo\n\nbar\n\n", true],
       ["CR LF line breaks treated like LR", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoo\r\nbar\r\n", true],
       ["CR line breaks treated like LR", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoo\rbar\r", true],
@@ skipping 18 matching lines @@
     for each ([testName, subscriptionBody, expectedResult] in tests)
     {
       resetSubscription(subscription);
       testRunner.runScheduledTasks(2);
       equal(subscription.downloadStatus, expectedResult ? "synchronize_ok" : "synchronize_checksum_mismatch", testName);
     }
   });
 
   test("Special comments", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     let comment, check;
     let tests = [
       ["! Homepage: http://example.com/", function() equal(subscription.homepage, "http://example.com/", "Valid homepage comment")],
       ["! Homepage: ssh://example.com/", function() equal(subscription.homepage, null, "Invalid homepage comment")],
       ["! Title: foo", function()
         {
           equal(subscription.title, "foo", "Title comment");
@@ skipping 16 matching lines @@
     {
       resetSubscription(subscription);
       testRunner.runScheduledTasks(2);
       check();
       deepEqual(subscription.filters, [Filter.fromText("foo"), Filter.fromText("bar")], "Special comment not added to filters");
     }
   });
 
   test("Redirects", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     function redirect_handler(metadata, response)
     {
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
       let result = "[Adblock]\nfoo\n!Redirect: http://127.0.0.1:1234/redirected\nbar";
       response.bodyOutputStream.write(result, result.length);
@@ skipping 37 matching lines @@
     FilterStorage.removeSubscription(FilterStorage.subscriptions[0]);
     FilterStorage.addSubscription(subscription);
 
     testRunner.runScheduledTasks(2);
     equal(FilterStorage.subscriptions[0], subscription, "Redirect not followed on redirect loop");
     equal(subscription.downloadStatus, "synchronize_connection_error", "Download status after redirect loop");
   });
 
   test("Fallback", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     Prefs.subscriptions_fallbackerrors = 3;
     Prefs.subscriptions_fallbackurl = "http://127.0.0.1:1234/fallback?%SUBSCRIPTION%&%CHANNELSTATUS%&%RESPONSESTATUS%";
 
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     // No valid response from fallback
 
     let requests = [];
     function handler(metadata, response)
@@ skipping 108 matching lines @@
     resetSubscription(subscription);
     FilterStorage.removeSubscription(FilterStorage.subscriptions[0]);
     FilterStorage.addSubscription(subscription);
 
     testRunner.runScheduledTasks(100);
     equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/redirected", "Fallback can still redirect even after a redirect loop");
   });
 
   test("State fields", function()
   {
-    // Always use average download interval
-    randomResult = 0.5;
-
     let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     FilterStorage.addSubscription(subscription);
 
     server.registerPathHandler("/subscription", function successHandler(metadata, response)
     {
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
       let result = "[Adblock]\n! Expires: 2 hours\nfoo\nbar";
       response.bodyOutputStream.write(result, result.length);
@@ skipping 15 matching lines @@
 
     testRunner.runScheduledTasks(2);
 
     equal(subscription.downloadStatus, "synchronize_connection_error", "downloadStatus after download error");
     equal(subscription.lastDownload * MILLIS_IN_SECOND, startTime + 2.1 * MILLIS_IN_HOUR, "lastDownload after download error");
     equal(subscription.lastSuccess * MILLIS_IN_SECOND, startTime + 0.1 * MILLIS_IN_HOUR, "lastSuccess after download error");
     equal(subscription.lastCheck * MILLIS_IN_SECOND, startTime + 3.1 * MILLIS_IN_HOUR, "lastCheck after download error");
     equal(subscription.errors, 1, "errors after download error");
   });
 })();