Issue 4128, 5138 - Add Parser and Serializer implemented in C++

test/subscriptionClasses.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";
 
 let {createSandbox} = require("./_common");
+const {withNAD, testEqualObjProperties} = require("./_test-utils");
 
 let Filter = null;
 let Subscription = null;
 let SpecialSubscription = null;
 let DownloadableSubscription = null;
 let FilterNotifier = null;
+let Parser = null;
+let Serializer = null;
 
 exports.setUp = function(callback)
 {
   let sandboxedRequire = createSandbox();
   ({Filter} = sandboxedRequire("../lib/filterClasses"));
   (
     {
       Subscription, SpecialSubscription, DownloadableSubscription
     } = sandboxedRequire("../lib/subscriptionClasses")
   );
   ({FilterNotifier} = sandboxedRequire("../lib/filterNotifier"));
+  ({Parser, Serializer} = sandboxedRequire("../lib/filterStorage"));
   callback();
 };
 
-function compareSubscription(test, url, expected, postInit)
+function testEqualSubscriptions(test, value, expected)
 {
-  expected.push("[Subscription]");
+  testEqualObjProperties(test, value, expected,
+    {
+      filters(propValue, expectedPropValue, message)
+      {
+        let {filterCount} = expected;
+        test.equal(value.filterCount, filterCount, "Different number of filters");
+        for (let i = 0; i < filterCount; ++i)
+          withNAD([1, 2], testEqualObjProperties)(test, value.filterAt(i), expected.filterAt(i));
+      }
+    });
+}
+
+function serializeSubscription(subscription)
+{
+  let serializer = Serializer.create();
+  try
+  {
+    serializer.serialize(subscription);
+    return serializer.data;
+  }
+  finally
+  {
+    serializer.delete();
+  }
+}
+
+function createSubscription(url, postInit)
+{
   let subscription = Subscription.fromURL(url);
-  if (postInit)
-    postInit(subscription);
-  let result = subscription.serialize().trim().split("\n");
-  test.equal(result.sort().join("\n"), expected.sort().join("\n"), url);
-  subscription.delete();
+  try
+  {
+    if (postInit)
+      postInit(subscription);
+  }
+  catch (ex)
+  {
+    subscription.delete();
+    subscription = null;
+    throw ex;
+  }
+  return subscription;
+}
+
+function testSerializeParse(test, subscription, processSerialized)
+{
+  let serializedData = serializeSubscription(subscription);
+  if (processSerialized)
+    processSerialized(serializedData);
+  let parser = Parser.create();
+  try
+  {
+    for (let line of serializedData.split("\n"))
+      parser.process(line);
+    parser.finalize();
+    test.equal(parser.subscriptionCount, 1);
+    withNAD(1, testEqualSubscriptions)(test, parser.subscriptionAt(0), subscription);
+  }
+  finally
+  {
+    parser.delete();
+  }
 }
 
 exports.testSubscriptionClassDefinitions = function(test)
 {
   test.equal(typeof Subscription, "function", "typeof Subscription");
   test.equal(typeof SpecialSubscription, "function", "typeof SpecialSubscription");
   test.equal(typeof DownloadableSubscription, "function", "typeof DownloadableSubscription");
 
   test.done();
 };
 
-exports.testSubscriptionsWithState = function(test)
+exports.testSerializationParsingPreservesSubscriptionProperties = function(test)
 {
-  compareSubscription(test, "~fl~", ["url=~fl~"]);
-  compareSubscription(test, "http://test/default", ["url=http://test/default", "title=http://test/default"]);
-  compareSubscription(test, "http://test/default_titled", ["url=http://test/default_titled", "title=test"], subscription =>
-  {
-    subscription.title = "test";
-  });
-  compareSubscription(test, "http://test/non_default", [
-    "url=http://test/non_default", "title=test", "fixedTitle=true",
-    "disabled=true", "lastSuccess=20015998341138",
-    "lastDownload=5124097847590911", "lastCheck=18446744069414584320",
-    "softExpiration=2682143778081159", "expires=4294967295",
-    "downloadStatus=foo", "errors=3", "version=24", "requiredVersion=0.6"
-  ], subscription =>
+  let localTestSerializeParse = (url, postInit) =>
+    withNAD(1, testSerializeParse)(test, createSubscription(url, postInit));
+  localTestSerializeParse("~fl~");
+  localTestSerializeParse("http://test/default");
+  localTestSerializeParse("http://test/default_titled", subscription =>
+    subscription.title = "test"
+  );
+  localTestSerializeParse("http://test/non_default", subscription =>
   {
     subscription.title = "test";
     subscription.fixedTitle = true;
     subscription.disabled = true;
     subscription.lastSuccess = 20015998341138;       // 0x123456789012
     subscription.lastDownload = 5124097847590911;    // 0x123456FFFFFFFF
     subscription.lastCheck = 18446744069414584320;   // 0xFFFFFFFF00000000
     subscription.softExpiration = 2682143778081159;  // 0x9876543210987
     subscription.expires = 4294967295;               // 0xFFFFFFFF
     subscription.downloadStatus = "foo";
     subscription.errors = 3;
     subscription.version = 24;
     subscription.requiredVersion = "0.6";
   });
-  compareSubscription(test, "~wl~", ["url=~wl~", "disabled=true", "title=Test group"], subscription =>
+  localTestSerializeParse("~wl~", subscription =>
   {
     subscription.title = "Test group";
     subscription.disabled = true;
   });
 
   test.done();
 };
 
 exports.testDefaultSubscriptionIDs = function(test)
 {
@@ skipping 13 matching lines @@
 };
 
 exports.testSubscriptionDefaults = function(test)
 {
   let tests = [
     ["blocking", "test"],
     ["whitelist", "@@test"],
     ["elemhide", "##test"],
     ["elemhide", "#@#test"],
     ["elemhide", "foo##[-abp-properties='foo']"],
-    ["", "!test"],
-    ["", "/??/"],
+    [null, "!test"],
+    [null, "/??/"],
     ["blocking whitelist", "test", "@@test"],
     ["blocking elemhide", "test", "##test"]
   ];
 
   for (let [defaults, ...filters] of tests)
   {
-    let expected = ["url=~user~" + filters.join("~")];
-    if (defaults)
-      expected.push("defaults= " + defaults);
-    compareSubscription(test, "~user~" + filters.join("~"), expected, subscription =>
-    {
-      for (let text of filters)
+    withNAD(1, testSerializeParse)(test, createSubscription("~user~" + filters.join("~"),
+      subscription =>
       {
-        let filter = Filter.fromText(text);
-        subscription.makeDefaultFor(filter);
-        filter.delete();
-      }
-    });
+        for (let text of filters)
+          withNAD(0, subscription.makeDefaultFor, subscription)(Filter.fromText(text));
+      }), (serializedData) =>
+      {
+        let foundDefaults = null;
+        for (let line of serializedData.split("\n"))
+        {
+          if (line.startsWith("defaults="))
+          {
+            foundDefaults = line;
+            break;
+          }
+        }
+        test.equal(foundDefaults, defaults ? "defaults= " + defaults : null, "unexpected serialization of defaults");
+      });
   }
   test.done();
 };
 
 exports.testGC = function(test)
 {
   let subscription1 = Subscription.fromURL("http://example.com/");
   test.equal(subscription1.lastDownload, 0, "Initial download time");
 
   subscription1.lastDownload = 432;
@@ skipping 80 matching lines @@
   checkFilterAt(0, "filter2", "First filter after releasing filter references");
   checkFilterAt(1, "filter1", "Second filter after releasing filter references");
 
   subscription.delete();
 
   test.done();
 };
 
 exports.testFilterSerialization = function(test)
 {
-  let filter1 = Filter.fromText("filter1");
-  let filter2 = Filter.fromText("filter2");
+  withNAD([0, 1, 2], (subscription, filter1, filter2) =>
+  {
+    testSerializeParse(test, subscription, (serializedData) =>
+      test.ok(!serializedData.includes("[Subscription filters]"), "Unexpected filters section")
+    );
 
-  let subscription = Subscription.fromURL("~user~12345");
-  test.equal(subscription.serializeFilters(), "", "No filters added");
+    subscription.insertFilterAt(filter1, 0);
+    subscription.insertFilterAt(filter1, 1);
+    subscription.insertFilterAt(filter2, 1);
 
-  subscription.insertFilterAt(filter1, 0);
-  subscription.insertFilterAt(filter1, 1);
-  subscription.insertFilterAt(filter2, 1);
-  test.equal(subscription.serializeFilters(), "[Subscription filters]\nfilter1\nfilter2\nfilter1\n", "Three filters added");
+    testSerializeParse(test, subscription, (serializedData) =>
+      test.ok(serializedData.includes("[Subscription filters]\nfilter1\nfilter2\nfilter1\n"), "Three filters added")
+    );
 
-  subscription.removeFilterAt(0);
-  test.equal(subscription.serializeFilters(), "[Subscription filters]\nfilter2\nfilter1\n", "One filter removed");
-
-  subscription.delete();
-  filter1.delete();
-  filter2.delete();
+    subscription.removeFilterAt(0);
+    testSerializeParse(test, subscription, (serializedData) =>
+      test.ok(serializedData.includes("[Subscription filters]\nfilter2\nfilter1\n"), "One filter removed")
+    );
+  })(Subscription.fromURL("~user~12345"), Filter.fromText("filter1"), Filter.fromText("filter2"));
 
   test.done();
 };
 
+exports.testEscapingFilterSerialization = function(test)
+{
+  withNAD(0, subscription =>
+  {
+    let subsriptionAddFilter = withNAD(0, subscription.insertFilterAt, subscription);
+
+    subsriptionAddFilter(Filter.fromText("[[x[x[[]x]"), 0);
+    subsriptionAddFilter(Filter.fromText("x[[x[x[[]x]x"), 1);
+    subsriptionAddFilter(Filter.fromText("x\\[]x"), 2);
+
+    withNAD(1, testSerializeParse)(test, subscription, (serializedData) =>
+      test.ok(serializedData.includes("[Subscription filters]\n\\[\\[x\\[x\\[\\[]x]\nx\\[\\[x\\[x\\[\\[]x]x\nx\\\\[]x\n"), "Filters should be escaped"));
+  })(Subscription.fromURL("~user~12345"));
+  test.done();
+};
+
 exports.testNotifications = function(test)
 {
   function checkNotifications(action, expected, message)
   {
     let result = null;
     let listener = (topic, subscription) =>
     {
       if (result)
         test.ok(false, "Got more that one notification - " + message);
       else
@@ skipping 86 matching lines @@
     subscription.errors++;
   }, ["subscription.errors", "http://example.com/"], "Increasing subscription.errors");
   checkNotifications(() =>
   {
     subscription.errors = 0;
   }, ["subscription.errors", "http://example.com/"], "Resetting subscription.erros");
 
   subscription.delete();
   test.done();
 };