Issue 6775 - Work around filter data stored in IndexedDB getting lost on Microsoft Edge

qunit/tests/indexedDBBackup.js

 "use strict";
 
 {
   const {IndexedDBBackup} = require("../../lib/indexedDBBackup");
   const info = require("info");
+  const {FilterStorage} = require("../../adblockpluscore/lib/filterStorage");
   const {Filter} = require("../../adblockpluscore/lib/filterClasses");
   const {Subscription, SpecialSubscription} =
     require("../../adblockpluscore/lib/subscriptionClasses");
 
-  let writeTime = 0;
-  let writeInterval = 100;
+  let backupDelay = 100;
+  let subscription = Subscription.fromObject({
+    title: "test",
+    url: "test.com",
+    homepage: "example.com",
+    lastSuccess: 8,
+    disabled: false,
+    lastDownload: 12,
+    lastCheck: 16,
+    softExpiration: 18,
+    expires: 20,
+    downloadStatus: "done",
+    errors: 3,
+    version: 24,
+    downloadCount: 1,
+    requiredVersion: "0.6"
+  });
+  let filter = Filter.fromText("example.com");
+  let specialSubscription = SpecialSubscription.createForFilter(filter);
 
   let testEdge = info.platform == "edgehtml" ? QUnit.test : QUnit.skip;
 
   QUnit.module("Microsoft Edge indexedDB backup", {
+    beforeEach()
+    {
+      this._storageLocalSet = browser.storage.local.set;
+      IndexedDBBackup.setBackupInterval(backupDelay);
+    },
     afterEach()
     {
-      IndexedDBBackup.init();
+      Object.defineProperty(
+        browser.storage.local, "set",
+        {value: this._storageLocalSet, enumerable: true}
+      );
+      IndexedDBBackup.setBackupInterval();
     }
   });
 
-  testEdge("Data serialization", () =>
+  testEdge("Backup creation", assert =>
   {
-    let subscription = Subscription.fromObject({
-      title: "test",
-      url: "test.com",
-      homepage: "example.com",
-      disabled: false,
-      lastSuccess: 8,
-      lastDownload: 12,
-      lastCheck: 16,
-      softExpiration: 18,
-      expires: 20,
-      downloadStatus: "done",
-      errors: 3,
-      version: 24,
-      downloadCount: 1,
-      requiredVersion: "0.6"
-    });
-    let filter = Filter.fromText("example.com");
-    let specialSubscription = SpecialSubscription.createForFilter(filter);
-
-    let expectedFormat = [
-      "",
-      "[Subscription]",
-      `homepage=${subscription.homepage}`,
-      `title=${subscription.title}`,
-      `url=${subscription.url}`,
-      `disabled=${subscription.disabled}`,
-      "",
-      "[Subscription]",
-      `url=${specialSubscription.url}`,
-      "defaults=blocking",
-      "",
-      "[Subscription filters]",
-      "example.com"
-    ];
-    let actualFormat = IndexedDBBackup.serialize([
-      subscription,
-      specialSubscription
-    ]);
-    deepEqual(actualFormat, expectedFormat, "formates the data correctly");

[Sebastian Noack, 2018/08/21 20:26:25]

Maybe we should test the serialization as part of the actual write operation.
Then we test the functionality end-to-end (which seems preferable), but also the
tests can be agnostic of the internal serialize() function.

[geo, 2018/08/31 15:49:25]

Done.

-  });
-
-  testEdge("Write time smaller than backup interval", assert =>
-  {
-    writeTime = 10;
-    testSaveSteps(assert);
-  });
-
-  testEdge("Write time greater than backup interval", assert =>
-  {
-    writeTime = 150;
     testSaveSteps(assert);
   });
 
   function testSaveSteps(assert)
   {
     let start = performance.now();
     let saveTimes = [];
+
     let steps = [
       {
         done: assert.async(),
-        check()
+        check(data)
         {
-          ok(start - saveTimes[0].start < writeInterval,
-            "first change is proccessed imediatelly");
+          let expectedFormat = [
+            "[Subscription]",
+            `url=${specialSubscription.url}`,
+            "defaults=blocking",
+            "[Subscription filters]",
+            "example.com",
+            "[Subscription]",
+            "homepage=example.com",
+            "title=test",
+            "url=test.com",
+            "disabled=false"
+          ];
+
+          ok(
+            saveTimes[0] - start >= backupDelay,
+            "first write is deferred"
+          );
+          deepEqual(
+            data.content,
+            expectedFormat,
+            "saved data has the correct information"
+          );
+
+          FilterStorage.removeSubscription(subscription);
+          FilterStorage.removeSubscription(specialSubscription);
         }
       },
       {
         done: assert.async(),
-        check()
+        check(data)
         {
-          ok(saveTimes[1].start - saveTimes[0].end >= writeInterval,
-            "next change is after the time limit");
+          ok(
+            saveTimes[1] - saveTimes[0] >= backupDelay,
+            "next changes are saved after the write delay"
+          );
+          deepEqual(
+            data.content, [], "saved data has the correct information"
+          );
         }
       }
     ];
-    let mockSave = () =>
+    let mockSave = data =>
     {
-      saveTimes.push({start: performance.now()});
-      return new Promise(resolve =>
+      let step = steps.shift();
+
+      saveTimes.push(performance.now());
+
+      setTimeout(() =>

[geo, 2018/09/05 15:59:08]

I've reintroduced this timeout because without it, this test seems to get stuck
after running the first 2 assertions.

       {
-        setTimeout(() =>
-        {
-          saveTimes[saveTimes.length - 1].end = performance.now();
-          let step = steps.shift();
-          step.check();
-          step.done();
-          resolve();
-        }, writeTime);
-      });
+        step.check(data["file:indexedDB-backup"]);
+        step.done();
+      }, 0);
     };
 
-    IndexedDBBackup.init(writeInterval, mockSave);
-    IndexedDBBackup.scheduleBackup();
-    setTimeout(IndexedDBBackup.scheduleBackup, writeTime / 2);
-    setTimeout(IndexedDBBackup.scheduleBackup, writeInterval);
+    Object.defineProperty(
+      browser.storage.local, "set",
+      {value: mockSave, enumerable: true}
+    );
+
+    FilterStorage.addSubscription(specialSubscription);
+    FilterStorage.addSubscription(subscription);
   }
 }