Made Synchronizer tests work again

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);
 
       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 = function() currentTime;
+      SynchronizerGlobal.Date.now = DownloaderGlobal.Date.now = function() currentTime;
 
       // Replace Math.random() function
-      this._origRandom = SynchronizerGlobal.Math.random;
-      SynchronizerGlobal.Math.random = function() randomResult;
+      this._origRandom = DownloaderGlobal.Math.random;
+      DownloaderGlobal.Math.random = function() randomResult;
 
       // Replace global timer variable
-      let timer = {__proto__: SynchronizerModule.timer, delay: 0.1 * MILLIS_IN_HOUR};
+      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.timer.cancel();
-      SynchronizerModule.timer = 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 -= initial;
+          maxHours -= skip;
         }
         this._runScheduledTasks(maxHours);
       }
 
       this._runScheduledTasks = function(maxHours)
       {
         let endTime = currentTime + maxHours * MILLIS_IN_HOUR;
         while (true)
         {
           let nextTask = null;
@@ skipping 25 matching lines @@
           else
             nextTask.nextExecution = currentTime + nextTask.delay;
         }
 
         currentTime = endTime;
       }
 
       this._skipTasks = function(hours)
       {
         let newTasks = [];
-        let endTime = currentTime + hours * MILLIS_IN_HOUR;
+        currentTime += hours * MILLIS_IN_HOUR;
         for each (let task in scheduledTasks)
         {
-          if (task.nextExecution >= endTime)
+          if (task.nextExecution >= currentTime)
             newTasks.push(task);
           else if (task.type != Components.interfaces.nsITimer.TYPE_ONE_SHOT)
           {
-            task.nextExecution = endTime;
+            task.nextExecution = currentTime;
             newTasks.push(task);
           }
         }
         scheduledTasks = newTasks;
       }
 
       this.getTimeOffset = function() (currentTime - startTime) / MILLIS_IN_HOUR;
 
       this.__defineGetter__("currentTime", function() currentTime);
     },
@@ skipping 15 matching lines @@
       stop();
       server.stop(function()
       {
         server = null;
         start();
       });
 
       if (this._origNow)
       {
         let SynchronizerGlobal = Cu.getGlobalForObject(Synchronizer);
-        SynchronizerGlobal.Date.now = this._origNow;
+        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 SynchronizerGlobal = Cu.getGlobalForObject(Synchronizer);
-        SynchronizerGlobal.Math.random = this._origRandom;
+        let SynchronizerModule = getModuleGlobal("synchronizer");
+        let DownloaderGlobal = Cu.getGlobalForObject(SynchronizerModule.downloader);
+        DownloaderGlobal.Math.random = this._origRandom;
         delete this._origRandom;
       }
 
       Synchronizer.init();
     }
   });
 
   function resetSubscription(subscription)
   {
     FilterStorage.updateSubscriptionFilters(subscription, []);
     subscription.lastCheck =  subscription.lastDownload =
-      subscription.lastSuccess = subscription.expires =
-      subscription.softExpiration = 0;
+      subscription.version = subscription.lastSuccess =
+      subscription.expires = subscription.softExpiration = 0;
+    subscription.title = "";
+    subscription.homepage = null;
     subscription.errors = 0;
     subscription.downloadStatus = null;
     subscription.requiredVersion = null;
-    subscription.nextURL = 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]\nfoo\nbar";
+      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"],
@@ skipping 15 matching lines @@
     FilterStorage.addSubscription(subscription2);
 
     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]\nfoo\nbar";
+      let result = "[Adblock]\n! ExPiREs: 1day\nfoo\nbar";
       response.bodyOutputStream.write(result, result.length);
     }
 
     server.registerPathHandler("/subscription1", handler);
     server.registerPathHandler("/subscription2", handler);
 
     testRunner.runScheduledTasks(55);
     deepEqual(requests, [
       [0.1, "GET", "/subscription1"],
       [2.1, "GET", "/subscription2"],
@@ skipping 13 matching lines @@
     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");
 
-      let result = test.header + "\nfoo\n!bar\n\n@@bas\n#bam";
+      let result = test.header + "\n!Expires: 8 hours\nfoo\n!bar\n\n@@bas\n#bam";
       response.bodyOutputStream.write(result, result.length);
     }
     server.registerPathHandler("/subscription", handler);
 
     let tests = [
       {header: "[Adblock]", downloadStatus: "synchronize_ok", requiredVersion: null},
       {header: "[Adblock Plus]", downloadStatus: "synchronize_ok", requiredVersion: null},
       {header: "(something)[Adblock]", downloadStatus: "synchronize_ok", requiredVersion: null},
       {header: "[Adblock Plus 0.0.1]", downloadStatus: "synchronize_ok", requiredVersion: "0.0.1"},
       {header: "[Adblock Plus 99.9]", downloadStatus: "synchronize_ok", requiredVersion: "99.9"},
@@ skipping 58 matching lines @@
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
       let result = "[Adblock]\nfoo\n!Expires: " + test.expiration + "\nbar";
       response.bodyOutputStream.write(result, result.length);
     }
     server.registerPathHandler("/subscription", handler);
 
     let tests = [
       {
-        expiration: "1 hour",   // Too small, will be corrected
+        expiration: "default",
         randomResult: 0.5,
-        requests: [0.1, 24.1]
+        requests: [0.1, 5 * 24 + 0.1]
+      },
+      {
+        expiration: "1 hours",  // Minimal expiration interval
+        randomResult: 0.5,
+        requests: [0.1, 1.1, 2.1, 3.1]
       },
       {
         expiration: "26 hours",
         randomResult: 0.5,
         requests: [0.1, 26.1]
       },
       {
         expiration: "2 days",
         randomResult: 0.5,
         requests: [0.1, 48.1]
@@ skipping 40 matching lines @@
         requests: [0.1, 85.1]
       }
     ]
 
     for each (test in tests)
     {
       requests = [];
       randomResult = test.randomResult;
       resetSubscription(subscription);
 
-      let maxHours = Math.round(Math.max.apply(null, test.requests)) + 12;
+      let maxHours = Math.round(Math.max.apply(null, test.requests)) + 1;
       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);
-
-      if (typeof test.skip == "number")
-      {
-        // Ensure that next time synchronizer triggers at time offset 0.1 again
-        testRunner.runScheduledTasks(0.1);
-      }
+    }
+  });
+
+  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],
+      ["Trailing line break not ignored", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoo\nbar", false],
+      ["Line breaks between lines not ignored", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoobar", false],
+      ["Lines with spaces not ignored", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\n \nfoo\n\nbar\n", false],
+      ["Extra content in checksum line is part of the checksum", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A foobar\nfoo\nbar\n", false],
+      ["= symbols after checksum are ignored", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A===\nfoo\nbar\n", true],
+      ["Header line is part of the checksum", "[Adblock Plus]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\nfoo\nbar\n", false],
+      ["Special comments are part of the checksum", "[Adblock]\n! Checksum: e/JCmqXny6Fn24b7JHsq/A\n! Expires: 1\nfoo\nbar\n", false],
+    ];
+
+    function handler(metadata, response)
+    {
+      response.setStatusLine("1.1", "200", "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      response.bodyOutputStream.write(subscriptionBody, subscriptionBody.length);
+    }
+    server.registerPathHandler("/subscription", handler);
+
+    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");
+          equal(subscription.fixedTitle, true, "Fixed title");
+        }],
+      ["! Version: 1234", function() equal(subscription.version, 1234, "Version comment")]
+    ];
+
+    function handler(metadata, response)
+    {
+      response.setStatusLine("1.1", "200", "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      let result = "[Adblock]\n" + comment + "\nfoo\nbar";
+      response.bodyOutputStream.write(result, result.length);
+    }
+    server.registerPathHandler("/subscription", handler);
+
+    for each([comment, check] in tests)
+    {
+      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);
     }
     server.registerPathHandler("/subscription", redirect_handler);
 
-    testRunner.runScheduledTasks(50);
-    equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/subscription", "Invalid redirect ignored");
+    testRunner.runScheduledTasks(30);
+    equal(FilterStorage.subscriptions[0], subscription, "Invalid redirect ignored");
+    equal(subscription.downloadStatus, "synchronize_connection_error", "Connection error recorded");
+    equal(subscription.errors, 2, "Number of download errors");
 
     let requests = [];
     function handler(metadata, response)
     {
       requests.push(testRunner.getTimeOffset());
 
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
-      let result = "[Adblock]\nfoo\nbar";
+      let result = "[Adblock]\nfoo\n! Expires: 8 hours\nbar";
       response.bodyOutputStream.write(result, result.length);
     }
     server.registerPathHandler("/redirected", handler);
 
     resetSubscription(subscription);
-    testRunner.runScheduledTasks(50);
+    testRunner.runScheduledTasks(15);
     equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/redirected", "Redirect followed");
-    deepEqual(requests, [24.1, 48.1], "Resulting requests");
+    deepEqual(requests, [0.1, 8.1], "Resulting requests");
+
+    server.registerPathHandler("/redirected", function(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/subscription\nbar";
+      response.bodyOutputStream.write(result, result.length);
+    })
+
+    let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
+    resetSubscription(subscription);
+    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?%URL%&%CHANNELSTATUS%&%RESPONSESTATUS%";
-
-    let subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
-    FilterStorage.addSubscription(subscription);
+    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)
     {
       requests.push(testRunner.getTimeOffset());
 
       response.setStatusLine("1.1", "404", "Not found");
     }
     server.registerPathHandler("/subscription", handler);
 
     testRunner.runScheduledTasks(100);
     deepEqual(requests, [0.1, 24.1, 48.1, 72.1, 96.1], "Continue trying if the fallback doesn't respond");
+
+    // Fallback giving "Gone" response
 
     resetSubscription(subscription);
     requests = [];
     fallbackParams = null;
     server.registerPathHandler("/fallback", function(metadata, response)
     {
       response.setStatusLine("1.1", "200", "OK");
       fallbackParams = decodeURIComponent(metadata.queryString);
 
       let result = "410 Gone";
       response.bodyOutputStream.write(result, result.length);
     });
 
     testRunner.runScheduledTasks(100);
     deepEqual(requests, [0.1, 24.1, 48.1], "Stop trying if the fallback responds with Gone");
-    equal(fallbackParams, "http://127.0.0.1:1234/subscription&0&404");
-
+    equal(fallbackParams, "http://127.0.0.1:1234/subscription&0&404", "Fallback arguments");
+
+    // Fallback redirecting to a missing file
+
+    subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
     resetSubscription(subscription);
     FilterStorage.removeSubscription(FilterStorage.subscriptions[0]);
     FilterStorage.addSubscription(subscription);
     requests = [];
 
     server.registerPathHandler("/fallback", function(metadata, response)
     {
       response.setStatusLine("1.1", "200", "OK");
 
       let result = "301 http://127.0.0.1:1234/redirected";
       response.bodyOutputStream.write(result, result.length);
     });
     testRunner.runScheduledTasks(100);
-    equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/subscription");
-    deepEqual(requests, [0.1, 24.1, 48.1, 96.1], "Come back after invalid redirect from fallback");
+    equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/subscription", "Ignore invalid redirect from fallback");
+    deepEqual(requests, [0.1, 24.1, 48.1, 72.1, 96.1], "Requests not affected by invalid redirect");
+
+    // Fallback redirecting to an existing file
 
     resetSubscription(subscription);
     requests = [];
     let redirectedRequests = [];
     server.registerPathHandler("/redirected", function(metadata, response)
     {
       redirectedRequests.push(testRunner.getTimeOffset());
 
       response.setStatusLine("1.1", "200", "OK");
       response.setHeader("Content-Type", "text/plain");
 
-      let result = "[Adblock]\nfoo\nbar";
+      let result = "[Adblock]\n!Expires: 1day\nfoo\nbar";
       response.bodyOutputStream.write(result, result.length);
     });
 
     testRunner.runScheduledTasks(100);
-    equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/redirected");
+    equal(FilterStorage.subscriptions[0].url, "http://127.0.0.1:1234/redirected", "Valid redirect from fallback is followed");
     deepEqual(requests, [0.1, 24.1, 48.1], "Stop polling original URL after a valid redirect from fallback");
-    deepEqual(redirectedRequests, [72.1, 96.1], "Request new URL after a valid redirect from fallback");
-  });
-
-  // TODO: Checksum verification
+    deepEqual(redirectedRequests, [48.1, 72.1, 96.1], "Request new URL after a valid redirect from fallback");
+
+    // Checksum mismatch
+
+    function handler2(metadata, response)
+    {
+      response.setStatusLine("1.1", "200", "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      let result = "[Adblock]\n! Checksum: wrong\nfoo\nbar";
+      response.bodyOutputStream.write(result, result.length);
+    }
+    server.registerPathHandler("/subscription", handler2);
+
+    subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
+    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", "Wrong checksum produces fallback request");
+
+    // Redirect loop
+
+    server.registerPathHandler("/subscription", function(metadata, response)
+    {
+      response.setStatusLine("1.1", "200", "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      let result = "[Adblock]\n! Redirect: http://127.0.0.1:1234/subscription2";
+      response.bodyOutputStream.write(result, result.length);
+    });
+    server.registerPathHandler("/subscription2", function(metadata, response)
+    {
+      response.setStatusLine("1.1", "200", "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      let result = "[Adblock]\n! Redirect: http://127.0.0.1:1234/subscription";
+      response.bodyOutputStream.write(result, result.length);
+    });
+
+    subscription = Subscription.fromURL("http://127.0.0.1:1234/subscription");
+    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);
+    });
+
+    let startTime = testRunner.currentTime;
+    testRunner.runScheduledTasks(2);
+
+    equal(subscription.downloadStatus, "synchronize_ok", "downloadStatus after successful download");
+    equal(subscription.lastDownload * MILLIS_IN_SECOND, startTime + 0.1 * MILLIS_IN_HOUR, "lastDownload after successful download");
+    equal(subscription.lastSuccess * MILLIS_IN_SECOND, startTime + 0.1 * MILLIS_IN_HOUR, "lastSuccess after successful download");
+    equal(subscription.lastCheck * MILLIS_IN_SECOND, startTime + 1.1 * MILLIS_IN_HOUR, "lastCheck after successful download");
+    equal(subscription.errors, 0, "errors after successful download");
+
+    server.registerPathHandler("/subscription", function errorHandler(metadata, response)
+    {
+      response.setStatusLine("1.1", "404", "Not Found");
+    });
+
+    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");
+  });
 })();