Attachment #9137954 for bug #1626728

Attachment #9137954: DO NOT LAND. TEST. Experimental changes to WPT test to use clear-site-data to induce Factory::Abort, doesn't crash things though. for bug #1626728

View | Details | Raw Unified | Return to bug 1626728
Collapse All | Expand All

(-)a/testing/web-platform/meta/clear-site-data/storage.https.html.ini (-1 lines)

Line	Link Here

Lines 1-2	Link Here

[storage.https.html]

[storage.https.html]

  disabled: https://bugzilla.mozilla.org/show_bug.cgi?id=1456995





      setup({"explicit_done": true});

      // There must be at least one test added synchronously, otherwise
      // testharness will complain.
      // TODO(@msramek): Find a way to avoid this dummy test.
      test(function() {}, "Populate backends.");

      TestUtils.populateStorage()
          .then(() => {
            return new Promise(function(resolve, reject) {
              promise_test(function(t) {
                return navigator.serviceWorker.getRegistration("support/").then(function(reg) {
                  return wait_for_state(t, reg.installing || reg.waiting || reg.active, 'activated');
                }).then(resolve, reject);
              });
            });
          })
          .then(() => {
            return new Promise(function (resolve) {
              // Create iFrame in the service worker's scope. This page will make a request
              // for another page that is only served by the service worker
              serviceWorkerTestPageIFrame = document.createElement("iframe");
              serviceWorkerTestPageIFrame.src = "support/page_using_service_worker.html";
              serviceWorkerTestPageIFrame.onload = function() { resolve(); };
              document.body.appendChild(serviceWorkerTestPageIFrame);
            });
          })
          .then(() => {
            const serviceWorkerResponseBody = fetchFromIFrame();

            promise_test(function() {
              return serviceWorkerResponseBody.then(function(body) {
                assert_equals(body, "FROM_SERVICE_WORKER", "Response should be from service worker");
              });
            }, "Baseline: Service worker responds to request");

            return serviceWorkerResponseBody;
          })
          .then(function() {
            const waitForControllerChange = new Promise(function(resolve) {
              serviceWorkerTestPageIFrame.contentWindow
                .navigator.serviceWorker.addEventListener("controllerchange", resolve);
            });
            // Navigate to a resource with a Clear-Site-Data header in
            // an iframe, then verify that all backends of the "storage"
            // datatype have been deleted.
            return new Promise(function(resolve, reject) {
              dump("!!!!! initiating clear-site-data invocation\n");
              window.addEventListener("message", resolve);
              var iframe = document.createElement("iframe");
              iframe.src = TestUtils.getClearSiteDataUrl([storage]);
              document.body.appendChild(iframe);
            }).then(function() {
              dump("!!!!! clear-site-data completed\n")
              TestUtils.STORAGE.forEach(function(backend) {
                var test_name =
                    "Clear backend when 'storage' is deleted: " + backend.name;

                promise_test(function() {
                  return backend.isEmpty().then(function(isEmpty) {
                    assert_true(
                      isEmpty,
                      backend.name + " should have been cleared.");
                  });
                }, test_name);
              });

              /*
              promise_test(function() {
                return fetchFromIFrame().then(function(body) {
                  assert_equals(body, "FROM_NETWORK", "Response should be from network and not from the service worker");
                });
              }, "Service worker no longer responds to requests");

              promise_test(function() {
                return waitForControllerChange.then(function() {
                  assert_false(!!serviceWorkerTestPageIFrame.contentWindow.navigator.serviceWorker.controller,
                    "Client should not have a controller");
                });
              }, "controllerchange event fires and client no longer has controller");
              */

              done();
            });
          });
    </script>
  </body>
</html>

-      Line
+  Link Here
-       Lines 22-171
      var TestUtils = (function() {
+  Link Here
   var TestUtils = {};
   /**
    * Various storage backends that are part of the 'storage' datatype.
    * @param{Array.<Datatype>}
    */
   TestUtils.STORAGE = [
+    {
+      "name": "Cache API",
+      "supported": function() { return true; },
+      "add": async function() {
+        let FILES_TO_CACHE = [
+          "navigation-insecure.html",
+          "navigation.https.html",
+          "resource.html",
+          "storage.https.html",
+          "support/iframe_executionContexts.html",
+          "support/page_using_service_worker.html",
+          "support/send_report.html",
+        ];
+        const REPEAT_COUNT = 100;
+        REQUESTS_TO_CACHE = [];
+        for (let i = 0; i < REPEAT_COUNT; i++) {
+          for (const filename of FILES_TO_CACHE) {
+            REQUESTS_TO_CACHE.push(`${filename}?foo=${i}`);
+          }
+        }
+        const cache = await caches.open("foo");
+        // try sticking a thing in that will never complete;
+        /*
+        dump("creating stream\n");
+        const myStream = window.MY_STREAM = new ReadableStream({
+          start(controller) {
+            this.controller = controller;
+            controller.enqueue("foo");
+          }
         });
+        dump("stream instantiated\n");
+        const myStreamResp = window.MY_RESP = new Response(myStream, { status : 200 });
+        dump("putting stream\n");
+        cache.put("/foo", myStreamResp);
+        dump("stream put is running\n");
+        */
+        await cache.addAll(REQUESTS_TO_CACHE);
+        const pendingResponses = Promise.all(REQUESTS_TO_CACHE.map((url) => {
+          return cache.match(url);
+        }));
+        const responses = await pendingResponses;
+        let iNext = 0;
+        const tarpit = window.STREAM_TARPIT = [];
+        const kickNext = () => {
+          const resp = responses[iNext++];
+          dump(`starting stream of ${resp.url}\n`);
+          const reader = resp.body.getReader();
+          const firstDataPromise = reader.read().then(() => {
+            dump(`  got some data for ${resp.url}\n`);
+            if (iNext < responses.length) {
+              kickNext();
+            }
+          });
+          tarpit.push({ reader, firstDataPromise });
+          return firstDataPromise;
+        };
+        const PRE_WAIT_COUNT = 10;
+        const POST_WAIT_COUNT = 10;
+        let sampleAt = 4;
+        let samplePromise;
+        for (let z = 0; z < PRE_WAIT_COUNT; z++) {
+          let prom = kickNext();
+          if (--sampleAt === 0) {
+            samplePromise = prom;
+          }
+        }
+        // wait for the pipeline to have been primed
+        await samplePromise;
+        dump("~~~~~DONE WAITING FOR SAMPLE\n");
+        for (let z = 0; z < POST_WAIT_COUNT; z++) {
+          kickNext();
+        }
       },
+      "isEmpty": async function() {
+        const hasCache = await caches.has("foo");
+        const knownCaches = await caches.keys();
+        return !hasCache && knownCaches.length === 0;
+            try {
+              var transaction = database.transaction(["store"]);
+              resolve(false);
+            } catch(error) {
+              // The database is empty. However, by testing that, we have also
+              // created it, which means that |onupgradeneeded| in the "add"
+              // method will not run the next time. Delete the database before
+              // reporting that it was empty.
+              var deletion = window.indexedDB.deleteDatabase("database");
+              deletion.onsuccess = resolve.bind(this, true);
+            } finally {
+              database.close();
+            }
+          };
+        });
+      }
     },
+    {
+      // TODO(@msramek): We should also test the PERSISTENT filesystem, however,
+      // that might require storage permissions.
+      "name": "filesystems",
+      "supported": function() {
+        return window.requestFileSystem || window.webkitRequestFileSystem;
+      },
+      "add": function() {
+        return new Promise(function(resolve, reject) {
+          var onSuccess = function(fileSystem) {
+            fileSystem.root.getFile('file', {"create": true}, resolve, resolve);
+          }
+          var onFailure = resolve;
+          var requestFileSystem =
+              window.requestFileSystem || window.webkitRequestFileSystem;
+          requestFileSystem(window.TEMPORARY, 1 /* 1B */,
+                            onSuccess, onFailure);
+        });
+      },
+      "isEmpty": function() {
+        return new Promise(function(resolve, reject) {
+          var onSuccess = function(fileSystem) {
+            fileSystem.root.getFile(
+                'file', {},
+                resolve.bind(this, false) /* opened successfully */,
+                resolve.bind(this, true) /* failed to open */);
+          }
+          var onFailure = resolve.bind(this, true);
+          var requestFileSystem =
+              window.requestFileSystem || window.webkitRequestFileSystem;
+          requestFileSystem(window.TEMPORARY, 1 /* 1B */,
+                            onSuccess, onFailure);
+        });
+      }
+    },
+    {
+      "name": "service workers",
+      "supported": function() { return !!navigator.serviceWorker; },
+      "add": function() {
+        return navigator.serviceWorker.register(
+            "support/service_worker.js",
+            { scope: "support/"});
+      },
+      "isEmpty": function() {
+        return new Promise(function(resolve, reject) {
+          navigator.serviceWorker.getRegistrations()
+              .then(function(registrations) {
+                resolve(!registrations.length);
+              });
+        });
+      }
+    },
+    {
+      "name": "WebSQL",
+      "supported": function() { return !!window.openDatabase; },
+      "add": function() {
+        return new Promise(function(resolve, reject) {
+          var database = window.openDatabase(
+              "database", "1.0", "database", 1024 /* 1 kB */);
+          database.transaction(function(context) {
+            context.executeSql("CREATE TABLE IF NOT EXISTS data (column)");
+            context.executeSql(
+                "INSERT INTO data (column) VALUES (1)", [], resolve);
+          });
+        });
+      },
+      "isEmpty": function() {
+        return new Promise(function(resolve, reject) {
+          var database = window.openDatabase(
+              "database", "1.0", "database", 1024 /* 1 kB */);
+          database.transaction(function(context) {
+            context.executeSql("CREATE TABLE IF NOT EXISTS data (column)");
+            context.executeSql(
+                "SELECT * FROM data", [],
+                function(transaction, result) {
+                  resolve(!result.rows.length);
+                });
+          });
+        });
+      }
+    }
   ].filter(function(backend) { return backend.supported(); });
   /**
    * All datatypes supported by Clear-Site-Data.
    * @param{Array.<Datatype>}
    */
   TestUtils.DATATYPES = [
+    {

Return to bug 1626728