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(writeInterval);
+      IndexedDBBackup.setBackupInterval(backupDelay);
     },
     afterEach()
     {
       Object.defineProperty(
         browser.storage.local, "set",
-        {value: this._storageLocalSet, enumerable: true});

[Sebastian Noack, 2018/09/04 21:00:01]

Nit: See previous comment(s) about wrapping argument lists, and where we prefer
to put the closing parenthesis. :)

Also check the code below, I see at least 2 more cases of inconsistently wrapped
argument lists.

[geo, 2018/09/05 14:04:34]

Done.

+        {value: this._storageLocalSet, enumerable: true}
+      );
       IndexedDBBackup.setBackupInterval();
     }
   });
 
-  testEdge("Write time smaller than backup interval", assert =>
+  testEdge("Backup creation", 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(data)
         {
           let expectedFormat = [
             "[Subscription]",
             `url=${specialSubscription.url}`,
             "defaults=blocking",
             "[Subscription filters]",
-            "example.com"
-          ];
-
-          ok(start - data.lastModified < writeInterval,
-            "first change is proccessed immediately");
-          deepEqual(
-            data.content, expectedFormat, "data is formatted correctly");
-
-          FilterStorage.addSubscription(subscription);
-        }
-      },
-      {
-        done: assert.async(),
-        check(data)
-        {
-          let expectedFormat = [
-            "[Subscription]",
-            `url=${specialSubscription.url}`,
-            "defaults=blocking",
-            "[Subscription filters]",
             "example.com",
             "[Subscription]",
             "homepage=example.com",
             "title=test",
             "url=test.com",
             "disabled=false"
           ];
-          ok(data.lastModified - saveTimes[0] >= writeInterval,
-            "next change is after the time limit");
+
+          ok(
+            saveTimes[0] - start >= backupDelay,
+            "first write is deferred"
+          );
           deepEqual(
-            data.content, expectedFormat, "data is formatted correctly");
+            data.content,
+            expectedFormat,
+            "saved data has the correct information"
+          );
 
           FilterStorage.removeSubscription(subscription);
           FilterStorage.removeSubscription(specialSubscription);
         }
       },
       {
         done: assert.async(),
         check(data)
         {
+          ok(
+            saveTimes[1] - saveTimes[0] >= backupDelay,
+            "next changes are saved after the write delay"
+          );
           deepEqual(
-            data.content, [], "multiple changes are treated in one write");
+            data.content, [], "saved data has the correct information"
+          );
         }
       }
     ];
-    let mockSave = (data) =>
+    let mockSave = data =>
     {
-      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(() =>
-        {
-          let step = steps.shift();
-          saveTimes.push(performance.now());
-          step.check(data["file:indexedDB-backup"]);
-          step.done();
-          resolve();
-        }, writeTime);
-      });
+        step.check(data["file:indexedDB-backup"]);
+        step.done();
+      }, 0);
     };
 
     Object.defineProperty(
       browser.storage.local, "set",
-      {value: mockSave, enumerable: true});
+      {value: mockSave, enumerable: true}
+    );
 
     FilterStorage.addSubscription(specialSubscription);
+    FilterStorage.addSubscription(subscription);
   }
 }