Issue 4878 - Start using ESLint for adblockpluscore

test/filterStorage_readwrite.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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/>.
  */
 
+/* globals __dirname */

[Wladimir Palant, 2017/03/02 14:07:08]

Is this necessary? Isn't it covered by env: node?

[kzar, 2017/03/08 12:33:56]

Whoops, no it wasn't necessary.

+
 "use strict";
 
-let {createSandbox, unexpectedError} = require("./_common");
+const {createSandbox, unexpectedError} = require("./_common");
 
 let Filter = null;
 let FilterNotifier = null;
 let FilterStorage = null;
 let IO = null;
 let Prefs = null;
 let Subscription = null;
 let ExternalSubscription = null;
 
 exports.setUp = function(callback)
 {
   let sandboxedRequire = createSandbox();
   (
     {Filter} = sandboxedRequire("../lib/filterClasses"),
     {FilterNotifier} = sandboxedRequire("../lib/filterNotifier"),
     {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
     {IO} = sandboxedRequire("./stub-modules/io"),
     {Prefs} = sandboxedRequire("./stub-modules/prefs"),
     {Subscription, ExternalSubscription} = sandboxedRequire("../lib/subscriptionClasses")
   );
 
   FilterStorage.addSubscription(Subscription.fromURL("~fl~"));
   callback();
-}
+};
 
 let testData = new Promise((resolve, reject) =>
 {
-  let fs = require("fs");
-  let path = require("path");
+  const fs = require("fs");
+  const path = require("path");
   let datapath = path.resolve(__dirname, "data", "patterns.ini");
 
   fs.readFile(datapath, "utf-8", (error, data) =>
   {
     if (error)
       reject(error);
     else
       resolve(data);
   });
 });
@@ skipping 29 matching lines @@
         curSection = {header: line, data: []};
       }
       else if (curSection && /\S/.test(line))
         curSection.data.push(line);
     }
     for (let section of sections)
     {
       section.key = section.header + " " + section.data[0];
       section.data.sort();
     }
-    sections.sort(function(a, b)
+    sections.sort((a, b) =>
     {
       if (a.key < b.key)
         return -1;
       else if (a.key > b.key)
         return 1;
-      else
-        return 0;
+      return 0;
     });
-    return sections.map(function(section) {
-      return [section.header].concat(section.data).join("\n");
-    }).join("\n");
+    return sections.map(
+      section => [section.header].concat(section.data).join("\n")
+    ).join("\n");
   }
 
   return testData.then(data =>
   {
     tempFile.contents = data;
     return loadFilters(tempFile);
   }).then(() =>
   {
     test.equal(FilterStorage.fileProperties.version, FilterStorage.formatVersion, "File format version");
 
     if (withExternal)
     {
-      let subscription = new ExternalSubscription("~external~external subscription ID", "External subscription");
-      subscription.filters = [Filter.fromText("foo"), Filter.fromText("bar")];
-      FilterStorage.addSubscription(subscription);
+      {
+        let subscription = new ExternalSubscription("~external~external subscription ID", "External subscription");
+        subscription.filters = [Filter.fromText("foo"), Filter.fromText("bar")];
+        FilterStorage.addSubscription(subscription);
+      }
 
       let externalSubscriptions = FilterStorage.subscriptions.filter(subscription => subscription instanceof ExternalSubscription);
       test.equal(externalSubscriptions.length, 1, "Number of external subscriptions after updateExternalSubscription");
 
       test.equal(externalSubscriptions[0].url, "~external~external subscription ID", "ID of external subscription");
       test.equal(externalSubscriptions[0].filters.length, 2, "Number of filters in external subscription");
     }
 
     return saveFilters(tempFile2);
   }).then(() => testData).then(expected =>
@@ skipping 15 matching lines @@
 exports.testLegacyGroups = {};
 
 for (let url of ["~wl~", "~fl~", "~eh~"])
 {
   exports.testLegacyGroups["read empty " + url] = function(test)
   {
     let data = "[Subscription]\nurl=" + url;
     let tempFile = IO.resolveFilePath("temp_patterns1.ini");
     tempFile.contents = data;
 
-    loadFilters(tempFile, function()
+    loadFilters(tempFile, () =>
     {
       test.equal(FilterStorage.subscriptions.length, 0, "Number of filter subscriptions");
     }).catch(unexpectedError.bind(test)).then(() => test.done());
   };
 
   exports.testLegacyGroups["read non-empty " + url] = function(test)
   {
     let data = "[Subscription]\nurl=" + url + "\n[Subscription filters]\nfoo";
     let tempFile = IO.resolveFilePath("temp_patterns1.ini");
     tempFile.contents = data;
@@ skipping 84 matching lines @@
   {
     test.ok(backupFile.exists(), "First backup created");
 
     backupFile.lastModifiedTime -= 10000;
     oldModifiedTime = backupFile.lastModifiedTime;
     return saveFilters(null);
   }).then(() =>
   {
     test.equal(backupFile.lastModifiedTime, oldModifiedTime, "Backup not overwritten if it is only 10 seconds old");
 
-    backupFile.lastModifiedTime -= 40*60*60*1000;
+    backupFile.lastModifiedTime -= 40 * 60 * 60 * 1000;
     oldModifiedTime = backupFile.lastModifiedTime;
     return saveFilters(null);
   }).then(() =>
   {
     test.notEqual(backupFile.lastModifiedTime, oldModifiedTime, "Backup overwritten if it is 40 hours old");
 
     test.ok(backupFile2.exists(), "Second backup created when first backup is overwritten");
 
     backupFile.lastModifiedTime -= 20000;
     oldModifiedTime = backupFile2.lastModifiedTime;
     return saveFilters(null);
   }).then(() =>
   {
     test.equal(backupFile2.lastModifiedTime, oldModifiedTime, "Second backup not overwritten if first one is only 20 seconds old");
 
-    backupFile.lastModifiedTime -= 25*60*60*1000;
+    backupFile.lastModifiedTime -= 25 * 60 * 60 * 1000;
     oldModifiedTime = backupFile2.lastModifiedTime;
     return saveFilters(null);
   }).then(() =>
   {
     test.notEqual(backupFile2.lastModifiedTime, oldModifiedTime, "Second backup overwritten if first one is 25 hours old");
 
     test.ok(!backupFile3.exists(), "Third backup not created with patternsbackups = 2");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };