Issue 6857 - Do not serialize empty special subscriptions

test/filterStorage_readwrite.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 {createSandbox, unexpectedError} = require("./_common");
 
 let Filter = null;
 let FilterStorage = null;
 let IO = null;
 let Prefs = null;
 let ExternalSubscription = null;
+let SpecialSubscription = null;
 
 exports.setUp = function(callback)
 {
   let sandboxedRequire = createSandbox();
   (
     {Filter} = sandboxedRequire("../lib/filterClasses"),
     {FilterStorage} = sandboxedRequire("../lib/filterStorage"),
     {IO} = sandboxedRequire("./stub-modules/io"),
     {Prefs} = sandboxedRequire("./stub-modules/prefs"),
-    {ExternalSubscription} = sandboxedRequire("../lib/subscriptionClasses")
+    {ExternalSubscription, SpecialSubscription} = sandboxedRequire("../lib/subscriptionClasses")
   );
 
   FilterStorage.addFilter(Filter.fromText("foobar"));
   callback();
 };
 
 let testData = new Promise((resolve, reject) =>
 {
   const fs = require("fs");
   const path = require("path");
@@ skipping 36 matching lines @@
   {
     if (a.key < b.key)
       return -1;
     else if (a.key > b.key)
       return 1;
     return 0;
   });
   return sections;
 }
 
-function testReadWrite(test, withExternal)
+function testReadWrite(test, withExternal, withEmptySpecial)
 {
   test.ok(!FilterStorage.initialized, "Uninitialized before the first load");
 
   return testData.then(data =>
   {
     IO._setFileContents(FilterStorage.sourceFile, data);
     return FilterStorage.loadFromDisk();
   }).then(() =>
   {
     test.ok(FilterStorage.initialized, "Initialize after the first load");
     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 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");
     }
 
+    if (withEmptySpecial)
+    {
+      let specialSubscription =
+        SpecialSubscription.createForFilter(Filter.fromText("!foo"));
+      FilterStorage.addSubscription(specialSubscription);
+
+      FilterStorage.removeFilter(Filter.fromText("!foo"), specialSubscription);
+
+      test.equal(specialSubscription.filters.length, 0,
+                 "No filters in special subscription");
+      test.ok(FilterStorage.subscriptions.indexOf(specialSubscription) != -1,
+              "Empty special subscription still in storage");
+    }
+
     return FilterStorage.saveToDisk();
   }).then(() => testData).then(expected =>
   {
     test.deepEqual(canonize(IO._getFileContents(FilterStorage.sourceFile)),
                canonize(expected), "Read/write result");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 }
 
 exports.testReadAndSaveToFile = function(test)
 {
   testReadWrite(test, false);
 };
 
 exports.testReadAndSaveToFileWithExternalSubscription = function(test)
 {
   testReadWrite(test, true);
 };
 
+exports.testReadAndSaveToFileWithEmptySpecial = function(test)
+{
+  testReadWrite(test, false, true);
+};
+
 exports.testImportExport = function(test)
 {
   testData.then(lines =>
   {
     if (lines.length && lines[lines.length - 1] == "")
       lines.pop();
 
     let importer = FilterStorage.importData();
     for (let line of lines)
       importer(line);
@@ skipping 94 matching lines @@
     return FilterStorage.restoreBackup(1);
   }).then(() =>
   {
     test.equal(FilterStorage.subscriptions[0].filters.length, 1, "Filter count after restoring backup");
     return FilterStorage.loadFromDisk();
   }).then(() =>
   {
     test.equal(FilterStorage.subscriptions[0].filters.length, 1, "Filter count after reloading");
   }).catch(unexpectedError.bind(test)).then(() => test.done());
 };