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

qunit/tests/ioIndexedDB.js

 "use strict";
 
 {
   const {IO} = require("io");
   const info = require("info");
+  const {IndexedDBBackup} = require("../../lib/indexedDBBackup");
 
   const testFileNames = {
     testData: "testData",
+    stat: "stat",
     simpleCheck: "simpleCheck",
     write: "writeCheck",
     read: "readCheck",
+    readBackup: "readBackup",
     rename: "renameCheck"
   };
   const testData = {
     fileName: "file:" + testFileNames.testData,
     content: [1, 2, 3],
     lastModified: Date.now()
   };
 
+  let _backupName = "test";
+  let _storageData = new Map();
+
+  IndexedDBBackup.getBackupData = () =>
+  {
+    return new Promise((resolve, reject) =>
+    {
+      if (_storageData.size)
+      {
+        resolve(_storageData.get(_backupName));
+      }
+      else
+        reject({type: "NoSuchFile"});
+    });
+  };
+
   let testEdge = info.platform == "edgehtml" ? QUnit.test : QUnit.skip;
 
   QUnit.module("Microsoft Edge filter storage", {
-    beforeEach()
+    beforeEach(assert)
     {
-      return prePopulateStorage();
+      prePopulateStorage(assert);
     },
-    afterEach()
+    afterEach(assert)
     {
-      return clearStorage();
+      _storageData.clear();
+      clearStorage(assert);
     }
   });
 
   testEdge("statFile", assert =>
   {
-    const noFileMsg = "returns correct value if file doesn't exist";
-    const fileExistsMsg = "returns correct value if file exists";
+    const noFileMsg = "returns correct value if file doesn't exist" +
+      " and there is no backup";
+    const fileExistsMsg = "returns correct value if file exists in indexedDB";
 
     ok(IO.statFile(testFileNames.simpleCheck) instanceof Promise,
       "returns a promise");
 
     asyncReadHelper(
       IO.statFile,
       testFileNames.testData,
       {exists: true, lastModified: testData.lastModified},
       fileExistsMsg,
       assert);
 
     asyncReadHelper(
       IO.statFile,
       testFileNames.simpleCheck,
       {exists: false},
       noFileMsg,
       assert);
   });
 
+  testEdge("restore backup", assert =>
+  {
+    let backupData = {
+      content: ["backup data"],
+      lastModified: Date.now()
+    };
+    let readFromFileMessage = "readFromFile return correct value," +
+      " if a data restore is performed";
+    _storageData.set(_backupName, backupData);
+
+    asyncReadHelper(
+      IO.statFile,
+      testFileNames.stat,
+      {exists: true, lastModified: backupData.lastModified},
+      "statFile return correct value, if a data restore is performed",
+      assert);
+
+    callsListeners(
+      testFileNames.readBackup,
+      assert, backupData.content,
+      readFromFileMessage);
+  });
+
   testEdge("writeToFile", assert =>
   {
     ok(IO.writeToFile(testFileNames.simpleCheck, ["test"]) instanceof Promise,
       "returns a promise");
 
     writesCorrectValue(assert);
   });
 
   function writesCorrectValue(assert)
   {
@@ skipping 16 matching lines @@
         deepEqual(
           writeCheck.content,
           result.content,
           "data has the correct content");
         done();
       });
   }
 
   testEdge("readFromFile", assert =>
   {
-    const noFileMsg = "returns correct value if file doesn't exist";
+    const noFileMsg = "returns correct value if file doesn't exist" +
+      " and there is no backup";
+    const fileExistsMsg = "calls listeners with the correct values";
 
     ok(IO.readFromFile(testFileNames.simpleCheck) instanceof Promise,
     "returns a promise");
 
     asyncReadHelper(
       IO.readFromFile,
       testFileNames.read,
       {type: "NoSuchFile"},
       noFileMsg,
       assert
     );
 
-    callsListeners(assert);
+    callsListeners(
+      testFileNames.testData,
+      assert,
+      testData.content,
+      fileExistsMsg);
   });
 
-  function callsListeners(assert)
+  function callsListeners(fileName, assert, expected, message)
   {
     let done = assert.async();
     let called = [];
 
-    IO.readFromFile(testFileNames.testData, (entry) => called.push(entry))
+    IO.readFromFile(fileName, (entry) => called.push(entry))
       .then(() =>
       {
-        deepEqual(
-          called,
-          testData.content,
-          "calls listeners with the correct values");
+        deepEqual(called, expected, message);
         done();
       });
   }
 
   testEdge("renameFile", assert =>
   {
     ok(IO.renameFile(testFileNames.simpleCheck) instanceof Promise,
       "returns a promise");
 
     checkRename(assert);
@@ skipping 39 matching lines @@
     {
       let db;
       let req = indexedDB.open("adblockplus", 1);
       req.onsuccess = (event) =>
       {
         db = event.currentTarget.result;
         let store = db
           .transaction(["file"], "readwrite")
           .objectStore("file");
 
-        store.get(fileName).onsuccess = (evt =>
-          resolve(evt.currentTarget.result)
-        );
+        store.get(fileName).onsuccess = evt =>
+          resolve(evt.currentTarget.result);
       };
     });
   }
 
-  function prePopulateStorage()
+  function prePopulateStorage(assert)
   {
-    return new Promise(resolve =>
+    let done = assert.async();
+    let db;
+    let req = indexedDB.open("adblockplus", 1);
+
+    req.onsuccess = (event) =>
     {
-      let db;
-      let req = indexedDB.open("adblockplus", 1);
+      db = event.currentTarget.result;
+      let store = db
+        .transaction(["file"], "readwrite")
+        .objectStore("file");
 
-      req.onsuccess = (event) =>
+      store.put(testData).onsuccess = done;
+    };
+  }
+
+  function clearStorage(assert)
+  {
+    let done = assert.async();
+    let db;
+    let req = indexedDB.open("adblockplus", 1);
+    req.onsuccess = event =>
+    {
+      db = event.currentTarget.result;
+      Promise.all(Object.values(testFileNames)
+      .map(fileName => new Promise(resolveFile =>
       {
-        db = event.currentTarget.result;
         let store = db
           .transaction(["file"], "readwrite")
           .objectStore("file");
 
-        store.put(testData).onsuccess = resolve;
-      };
-    });
-  }
-
-  function clearStorage()
-  {
-    return new Promise(resolve =>
-      {
-      let db;
-      let req = indexedDB.open("adblockplus", 1);
-
-      req.onsuccess = (event) =>
-      {
-        db = event.currentTarget.result;
-        let files = Object.keys(testFileNames)
-          .map(fileName => new Promise((resolveFile, reject) =>
-          {
-            let store = db
-              .transaction(["file"], "readwrite")
-              .objectStore("file");
-
-            store.delete("file:" + fileName).onsuccess = resolveFile;
-          }));
-
-        Promise.all(files).then(resolve);
-      };
-    });
+        store.delete("file:" + fileName).onsuccess = resolveFile;
+      })))
+      .then(() => done());
+    };
   }
 }