Issue 6820 - Move tests to mocha

test/synchronizer.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 "use strict";
 
 const assert = require("assert");
 let {
-  createSandbox, setupTimerAndXMLHttp, setupRandomResult, Cr,
+  createSandbox, setupTimerAndFetch, setupRandomResult,
   MILLIS_IN_SECOND, MILLIS_IN_HOUR
 } = require("./_common");
 
 let filterStorage = null;
 let Prefs = null;
 let Subscription = null;
 
 describe("Synchronizer", () =>
 {
   let runner = {};
 
   beforeEach(() =>
   {
     runner = {};
-    let globals = Object.assign({}, setupTimerAndXMLHttp.call(runner),
-      setupRandomResult.call(runner));
+    let globals = Object.assign({}, setupTimerAndFetch.call(runner),
+                                setupRandomResult.call(runner));
 
     let sandboxedRequire = createSandbox({globals});
     (
       {filterStorage} = sandboxedRequire("../lib/filterStorage"),
       {Prefs} = sandboxedRequire("./stub-modules/prefs"),
       {Subscription} = sandboxedRequire("../lib/subscriptionClasses"),
       sandboxedRequire("../lib/synchronizer")
     );
   });
 
@@ skipping 16 matching lines @@
   {
     it("One Subscription", () =>
     {
       let subscription = Subscription.fromURL("http://example.com/subscription");
       filterStorage.addSubscription(subscription);
 
       let requests = [];
       runner.registerHandler("/subscription", metadata =>
       {
         requests.push([runner.getTimeOffset(), metadata.method, metadata.path]);
-        return [Cr.NS_OK, 200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
+        return [200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
       });
 
       return runner.runScheduledTasks(50).then(() =>
       {
         assert.deepEqual(requests, [
           [0 + initialDelay, "GET", "/subscription"],
           [24 + initialDelay, "GET", "/subscription"],
           [48 + initialDelay, "GET", "/subscription"]
         ], "Requests after 50 hours");
       });
     });
 
     it("Two Subscriptions", () =>
     {
       let subscription1 = Subscription.fromURL("http://example.com/subscription1");
       filterStorage.addSubscription(subscription1);
 
       let subscription2 = Subscription.fromURL("http://example.com/subscription2");
       subscription2.expires =
         subscription2.softExpiration =
         (runner.currentTime + 2 * MILLIS_IN_HOUR) / MILLIS_IN_SECOND;
       filterStorage.addSubscription(subscription2);
 
       let requests = [];
       let handler = metadata =>
       {
         requests.push([runner.getTimeOffset(), metadata.method, metadata.path]);
-        return [Cr.NS_OK, 200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
+        return [200, "[Adblock]\n! ExPiREs: 1day\nfoo\nbar"];
       };
 
       runner.registerHandler("/subscription1", handler);
       runner.registerHandler("/subscription2", handler);
 
       return runner.runScheduledTasks(55).then(() =>
       {
         assert.deepEqual(requests, [
           [0 + initialDelay, "GET", "/subscription1"],
           [2 + initialDelay, "GET", "/subscription2"],
@@ skipping 17 matching lines @@
       {header: "[Foo]", downloadStatus: "synchronize_invalid_data", requiredVersion: null}
     ])
     {
       it(currentTest.header, () =>
       {
         let subscription = Subscription.fromURL("http://example.com/subscription");
         filterStorage.addSubscription(subscription);
 
         runner.registerHandler("/subscription", metadata =>
         {
-          return [Cr.NS_OK, 200, currentTest.header + "\n!Expires: 8 hours\nfoo\n!bar\n\n@@bas\n#bam"];
+          return [200, currentTest.header + "\n!Expires: 8 hours\nfoo\n!bar\n\n@@bas\n#bam"];
         });
 
         return runner.runScheduledTasks(2).then(() =>
         {
           assert.equal(subscription.downloadStatus, currentTest.downloadStatus, "Download status");
           assert.equal(subscription.requiredVersion, currentTest.requiredVersion, "Required version");
 
           if (currentTest.downloadStatus == "synchronize_ok")
           {
             assert.deepEqual([...subscription.filterText()], ["foo", "!bar", "@@bas", "#bam"], "Resulting subscription filters");
@@ skipping 102 matching lines @@
 
       it(testId, () =>
       {
         let subscription = Subscription.fromURL("http://example.com/subscription");
         filterStorage.addSubscription(subscription);
 
         let requests = [];
         runner.registerHandler("/subscription", metadata =>
         {
           requests.push(runner.getTimeOffset());
-          return [Cr.NS_OK, 200, "[Adblock]\n!Expires: " + currentTest.expiration + "\nbar"];
+          return [200, "[Adblock]\n!Expires: " + currentTest.expiration + "\nbar"];
         });
 
         runner.randomResult = currentTest.randomResult;
 
         let maxHours = Math.round(Math.max.apply(null, currentTest.requests)) + 1;
         return runner.runScheduledTasks(maxHours, currentTest.skipAfter, currentTest.skip).then(() =>
         {
           assert.deepEqual(requests, currentTest.requests, "Requests");
         });
       });
@@ skipping 22 matching lines @@
       }]
     ])
     {
       it(comment, () =>
       {
         let subscription = Subscription.fromURL("http://example.com/subscription");
         filterStorage.addSubscription(subscription);
 
         runner.registerHandler("/subscription", metadata =>
         {
-          return [Cr.NS_OK, 200, "[Adblock]\n" + comment + "\nfoo\nbar"];
+          return [200, "[Adblock]\n" + comment + "\nfoo\nbar"];
         });
 
         return runner.runScheduledTasks(2).then(() =>
         {
           check(subscription);
           assert.deepEqual([...subscription.filterText()], ["foo", "bar"], "Special comment not added to filters");
         });
       });
     }
   });
 
   it("Redirects", () =>
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
     filterStorage.addSubscription(subscription);
 
     runner.registerHandler("/subscription", metadata =>
     {
-      return [Cr.NS_OK, 200, "[Adblock]\n!Redirect: http://example.com/redirected\nbar"];
+      return [200, "[Adblock]\n!Redirect: http://example.com/redirected\nbar"];
     });
 
     let requests;
 
     return runner.runScheduledTasks(30).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0], subscription, "Invalid redirect ignored");
       assert.equal(subscription.downloadStatus, "synchronize_connection_error", "Connection error recorded");
       assert.equal(subscription.errors, 2, "Number of download errors");
 
       requests = [];
 
       runner.registerHandler("/redirected", metadata =>
       {
         requests.push(runner.getTimeOffset());
-        return [Cr.NS_OK, 200, "[Adblock]\n! Expires: 8 hours\nbar"];
+        return [200, "[Adblock]\n! Expires: 8 hours\nbar"];
       });
 
       resetSubscription(subscription);
       return runner.runScheduledTasks(15);
     }).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Redirect followed");
       assert.deepEqual(requests, [0 + initialDelay, 8 + initialDelay], "Resulting requests");
 
       runner.registerHandler("/redirected", metadata =>
       {
-        return [Cr.NS_OK, 200, "[Adblock]\n!Redirect: http://example.com/subscription\nbar"];
+        return [200, "[Adblock]\n!Redirect: http://example.com/subscription\nbar"];
       });
 
       subscription = Subscription.fromURL("http://example.com/subscription");
       resetSubscription(subscription);
       filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
       filterStorage.addSubscription(subscription);
 
       return runner.runScheduledTasks(2);
     }).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0], subscription, "Redirect not followed on redirect loop");
       assert.equal(subscription.downloadStatus, "synchronize_connection_error", "Download status after redirect loop");
     });
   });
 
   it("Fallback", () =>
   {
     Prefs.subscriptions_fallbackerrors = 3;
-    Prefs.subscriptions_fallbackurl = "http://example.com/fallback?%SUBSCRIPTION%&%CHANNELSTATUS%&%RESPONSESTATUS%";
+    Prefs.subscriptions_fallbackurl = "http://example.com/fallback?%SUBSCRIPTION%&%RESPONSESTATUS%";
 
     let subscription = Subscription.fromURL("http://example.com/subscription");
     filterStorage.addSubscription(subscription);
 
     // No valid response from fallback
 
     let requests = [];
     let fallbackParams;
     let redirectedRequests;
     runner.registerHandler("/subscription", metadata =>
     {
       requests.push(runner.getTimeOffset());
-      return [Cr.NS_OK, 404, ""];
+      return [404, ""];
     });
 
     return runner.runScheduledTasks(100).then(() =>
     {
       assert.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay, 72 + initialDelay, 96 + initialDelay], "Continue trying if the fallback doesn't respond");
 
       // Fallback giving "Gone" response
 
       resetSubscription(subscription);
       requests = [];
       fallbackParams = null;
       runner.registerHandler("/fallback", metadata =>
       {
         fallbackParams = decodeURIComponent(metadata.queryString);
-        return [Cr.NS_OK, 200, "410 Gone"];
+        return [200, "410 Gone"];
       });
 
       return runner.runScheduledTasks(100);
     }).then(() =>
     {
       assert.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay], "Stop trying if the fallback responds with Gone");
-      assert.equal(fallbackParams, "http://example.com/subscription&0&404", "Fallback arguments");
+      assert.equal(fallbackParams, "http://example.com/subscription&404", "Fallback arguments");
 
       // Fallback redirecting to a missing file
 
       subscription = Subscription.fromURL("http://example.com/subscription");
       resetSubscription(subscription);
       filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
       filterStorage.addSubscription(subscription);
       requests = [];
 
       runner.registerHandler("/fallback", metadata =>
       {
-        return [Cr.NS_OK, 200, "301 http://example.com/redirected"];
+        return [200, "301 http://example.com/redirected"];
       });
       return runner.runScheduledTasks(100);
     }).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0].url, "http://example.com/subscription", "Ignore invalid redirect from fallback");
       assert.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay, 72 + initialDelay, 96 + initialDelay], "Requests not affected by invalid redirect");
 
       // Fallback redirecting to an existing file
 
       resetSubscription(subscription);
       requests = [];
       redirectedRequests = [];
       runner.registerHandler("/redirected", metadata =>
       {
         redirectedRequests.push(runner.getTimeOffset());
-        return [Cr.NS_OK, 200, "[Adblock]\n!Expires: 1day\nfoo\nbar"];
+        return [200, "[Adblock]\n!Expires: 1day\nfoo\nbar"];
       });
 
       return runner.runScheduledTasks(100);
     }).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Valid redirect from fallback is followed");
       assert.deepEqual(requests, [0 + initialDelay, 24 + initialDelay, 48 + initialDelay], "Stop polling original URL after a valid redirect from fallback");
       assert.deepEqual(redirectedRequests, [48 + initialDelay, 72 + initialDelay, 96 + initialDelay], "Request new URL after a valid redirect from fallback");
 
       // Redirect loop
 
       runner.registerHandler("/subscription", metadata =>
       {
-        return [Cr.NS_OK, 200, "[Adblock]\n! Redirect: http://example.com/subscription2"];
+        return [200, "[Adblock]\n! Redirect: http://example.com/subscription2"];
       });
       runner.registerHandler("/subscription2", metadata =>
       {
-        return [Cr.NS_OK, 200, "[Adblock]\n! Redirect: http://example.com/subscription"];
+        return [200, "[Adblock]\n! Redirect: http://example.com/subscription"];
       });
 
       subscription = Subscription.fromURL("http://example.com/subscription");
       resetSubscription(subscription);
       filterStorage.removeSubscription([...filterStorage.subscriptions()][0]);
       filterStorage.addSubscription(subscription);
 
       return runner.runScheduledTasks(100);
     }).then(() =>
     {
       assert.equal([...filterStorage.subscriptions()][0].url, "http://example.com/redirected", "Fallback can still redirect even after a redirect loop");
     });
   });
 
   it("State Fields", () =>
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
     filterStorage.addSubscription(subscription);
 
     runner.registerHandler("/subscription", metadata =>
     {
-      return [Cr.NS_OK, 200, "[Adblock]\n! Expires: 2 hours\nfoo\nbar"];
+      return [200, "[Adblock]\n! Expires: 2 hours\nfoo\nbar"];
     });
 
     let startTime = runner.currentTime;
     return runner.runScheduledTasks(2).then(() =>
     {
       assert.equal(subscription.downloadStatus, "synchronize_ok", "downloadStatus after successful download");
       assert.equal(subscription.lastDownload * MILLIS_IN_SECOND, startTime + initialDelay * MILLIS_IN_HOUR, "lastDownload after successful download");
       assert.equal(subscription.lastSuccess * MILLIS_IN_SECOND, startTime + initialDelay * MILLIS_IN_HOUR, "lastSuccess after successful download");
       assert.equal(subscription.lastCheck * MILLIS_IN_SECOND, startTime + (1 + initialDelay) * MILLIS_IN_HOUR, "lastCheck after successful download");
       assert.equal(subscription.errors, 0, "errors after successful download");
 
       runner.registerHandler("/subscription", metadata =>
       {
-        return [Cr.NS_ERROR_FAILURE, 0, ""];
+        return [0, ""];
       });
 
       return runner.runScheduledTasks(2);
     }).then(() =>
     {
       assert.equal(subscription.downloadStatus, "synchronize_connection_error", "downloadStatus after connection error");
       assert.equal(subscription.lastDownload * MILLIS_IN_SECOND, startTime + (2 + initialDelay) * MILLIS_IN_HOUR, "lastDownload after connection error");
       assert.equal(subscription.lastSuccess * MILLIS_IN_SECOND, startTime + initialDelay * MILLIS_IN_HOUR, "lastSuccess after connection error");
       assert.equal(subscription.lastCheck * MILLIS_IN_SECOND, startTime + (3 + initialDelay) * MILLIS_IN_HOUR, "lastCheck after connection error");
       assert.equal(subscription.errors, 1, "errors after connection error");
 
       runner.registerHandler("/subscription", metadata =>
       {
-        return [Cr.NS_OK, 404, ""];
+        return [404, ""];
       });
 
       return runner.runScheduledTasks(24);
     }).then(() =>
     {
       assert.equal(subscription.downloadStatus, "synchronize_connection_error", "downloadStatus after download error");
       assert.equal(subscription.lastDownload * MILLIS_IN_SECOND, startTime + (26 + initialDelay) * MILLIS_IN_HOUR, "lastDownload after download error");
       assert.equal(subscription.lastSuccess * MILLIS_IN_SECOND, startTime + initialDelay * MILLIS_IN_HOUR, "lastSuccess after download error");
       assert.equal(subscription.lastCheck * MILLIS_IN_SECOND, startTime + (27 + initialDelay) * MILLIS_IN_HOUR, "lastCheck after download error");
       assert.equal(subscription.errors, 2, "errors after download error");
     });
   });
 
   it("Special Comment Ordering", () =>
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
     filterStorage.addSubscription(subscription);
 
     runner.registerHandler("/subscription", metadata =>
     {
-      return [Cr.NS_OK, 200, "[Adblock]\n! Special Comment: x\n!foo\n! Title: foobar\nfoo\nbar"];
+      return [0, ""];
     });
 
     return runner.runScheduledTasks(1).then(() =>
     {
       assert.equal(subscription.title, "http://example.com/subscription", "make sure title was not found");
     });
   });
 
   it("Unkown Special Comments", () =>
   {
     let subscription = Subscription.fromURL("http://example.com/subscription");
     filterStorage.addSubscription(subscription);
 
     runner.registerHandler("/subscription", metadata =>
     {
       // To test allowing unknown special comments like `! :`, `!!@#$%^&*() : `, and `! Some Unknown Comment : `
-      return [Cr.NS_OK, 200, "[Adblock]\n! :\n! !@#$%^&*() :\n! Some Unknown Comment :\n! Title: foobar\nfoo\nbar"];
+      return [200, "[Adblock]\n! :\n! !@#$%^&*() :\n! Some Unknown Comment :\n! Title: foobar\nfoo\nbar"];
     });
 
     return runner.runScheduledTasks(1).then(() =>
     {
       assert.equal(subscription.title, "foobar", "make sure title was found");
     });
   });
 });