summaryrefslogtreecommitdiffstats
path: root/dom/serviceworkers/test/fetch_event_worker.js
diff options
context:
space:
mode:
Diffstat (limited to 'dom/serviceworkers/test/fetch_event_worker.js')
-rw-r--r--dom/serviceworkers/test/fetch_event_worker.js364
1 files changed, 364 insertions, 0 deletions
diff --git a/dom/serviceworkers/test/fetch_event_worker.js b/dom/serviceworkers/test/fetch_event_worker.js
new file mode 100644
index 0000000000..b022ca4175
--- /dev/null
+++ b/dom/serviceworkers/test/fetch_event_worker.js
@@ -0,0 +1,364 @@
+// eslint-disable-next-line complexity
+onfetch = function (ev) {
+ if (ev.request.url.includes("ignore")) {
+ return;
+ }
+
+ if (ev.request.url.includes("bare-synthesized.txt")) {
+ ev.respondWith(
+ Promise.resolve(new Response("synthesized response body", {}))
+ );
+ } else if (ev.request.url.includes("file_CrossSiteXHR_server.sjs")) {
+ // N.B. this response would break the rules of CORS if it were allowed, but
+ // this test relies upon the preflight request not being intercepted and
+ // thus this response should not be used.
+ if (ev.request.method == "OPTIONS") {
+ ev.respondWith(
+ new Response("", {
+ headers: {
+ "Access-Control-Allow-Origin": "*",
+ "Access-Control-Allow-Headers": "X-Unsafe",
+ },
+ })
+ );
+ } else if (ev.request.url.includes("example.org")) {
+ ev.respondWith(fetch(ev.request));
+ }
+ } else if (ev.request.url.includes("synthesized-404.txt")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("synthesized response body", { status: 404 })
+ )
+ );
+ } else if (ev.request.url.includes("synthesized-headers.txt")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("synthesized response body", {
+ headers: {
+ "X-Custom-Greeting": "Hello",
+ },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("test-respondwith-response.txt")) {
+ ev.respondWith(new Response("test-respondwith-response response body", {}));
+ } else if (ev.request.url.includes("synthesized-redirect-real-file.txt")) {
+ ev.respondWith(Promise.resolve(Response.redirect("fetch/real-file.txt")));
+ } else if (
+ ev.request.url.includes("synthesized-redirect-twice-real-file.txt")
+ ) {
+ ev.respondWith(
+ Promise.resolve(Response.redirect("synthesized-redirect-real-file.txt"))
+ );
+ } else if (ev.request.url.includes("synthesized-redirect-synthesized.txt")) {
+ ev.respondWith(Promise.resolve(Response.redirect("bare-synthesized.txt")));
+ } else if (
+ ev.request.url.includes("synthesized-redirect-twice-synthesized.txt")
+ ) {
+ ev.respondWith(
+ Promise.resolve(Response.redirect("synthesized-redirect-synthesized.txt"))
+ );
+ } else if (ev.request.url.includes("rejected.txt")) {
+ ev.respondWith(Promise.reject());
+ } else if (ev.request.url.includes("nonresponse.txt")) {
+ ev.respondWith(Promise.resolve(5));
+ } else if (ev.request.url.includes("nonresponse2.txt")) {
+ ev.respondWith(Promise.resolve({}));
+ } else if (ev.request.url.includes("nonpromise.txt")) {
+ try {
+ // This should coerce to Promise(5) instead of throwing
+ ev.respondWith(5);
+ } catch (e) {
+ // test is expecting failure, so return a success if we get a thrown
+ // exception
+ ev.respondWith(new Response("respondWith(5) threw " + e));
+ }
+ } else if (ev.request.url.includes("headers.txt")) {
+ var ok = true;
+ ok &= ev.request.headers.get("X-Test1") == "header1";
+ ok &= ev.request.headers.get("X-Test2") == "header2";
+ ev.respondWith(Promise.resolve(new Response(ok.toString(), {})));
+ } else if (ev.request.url.includes("readable-stream.txt")) {
+ ev.respondWith(
+ new Response(
+ new ReadableStream({
+ start(controller) {
+ controller.enqueue(
+ new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
+ );
+ controller.close();
+ },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("readable-stream-locked.txt")) {
+ let stream = new ReadableStream({
+ start(controller) {
+ controller.enqueue(
+ new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
+ );
+ controller.close();
+ },
+ });
+
+ ev.respondWith(new Response(stream));
+
+ // This locks the stream.
+ stream.getReader();
+ } else if (ev.request.url.includes("readable-stream-with-exception.txt")) {
+ ev.respondWith(
+ new Response(
+ new ReadableStream({
+ start(controller) {},
+ pull() {
+ throw "EXCEPTION!";
+ },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("readable-stream-with-exception2.txt")) {
+ ev.respondWith(
+ new Response(
+ new ReadableStream({
+ _controller: null,
+ _count: 0,
+
+ start(controller) {
+ this._controller = controller;
+ },
+ pull() {
+ if (++this._count == 5) {
+ throw "EXCEPTION 2!";
+ }
+ this._controller.enqueue(new Uint8Array([this._count]));
+ },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("readable-stream-already-consumed.txt")) {
+ let r = new Response(
+ new ReadableStream({
+ start(controller) {
+ controller.enqueue(
+ new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21])
+ );
+ controller.close();
+ },
+ })
+ );
+
+ r.blob();
+
+ ev.respondWith(r);
+ } else if (ev.request.url.includes("user-pass")) {
+ ev.respondWith(new Response(ev.request.url));
+ } else if (ev.request.url.includes("nonexistent_image.gif")) {
+ var imageAsBinaryString = atob(
+ "R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs"
+ );
+ var imageLength = imageAsBinaryString.length;
+
+ // If we just pass |imageAsBinaryString| to the Response constructor, an
+ // encoding conversion occurs that corrupts the image. Instead, we need to
+ // convert it to a typed array.
+ // typed array.
+ var imageAsArray = new Uint8Array(imageLength);
+ for (var i = 0; i < imageLength; ++i) {
+ imageAsArray[i] = imageAsBinaryString.charCodeAt(i);
+ }
+
+ ev.respondWith(
+ Promise.resolve(
+ new Response(imageAsArray, { headers: { "Content-Type": "image/gif" } })
+ )
+ );
+ } else if (ev.request.url.includes("nonexistent_script.js")) {
+ ev.respondWith(
+ Promise.resolve(new Response("check_intercepted_script();", {}))
+ );
+ } else if (ev.request.url.includes("nonexistent_stylesheet.css")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("#style-test { background-color: black !important; }", {
+ headers: {
+ "Content-Type": "text/css",
+ },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("nonexistent_page.html")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response(
+ "<script>window.frameElement.test_result = true;</script>",
+ {
+ headers: {
+ "Content-Type": "text/html",
+ },
+ }
+ )
+ )
+ );
+ } else if (ev.request.url.includes("navigate.html")) {
+ var requests = [
+ // should not throw
+ new Request(ev.request),
+ new Request(ev.request, undefined),
+ new Request(ev.request, null),
+ new Request(ev.request, {}),
+ new Request(ev.request, { someUnrelatedProperty: 42 }),
+ new Request(ev.request, { method: "GET" }),
+ ];
+ ev.respondWith(
+ Promise.resolve(
+ new Response(
+ "<script>window.frameElement.test_result = true;</script>",
+ {
+ headers: {
+ "Content-Type": "text/html",
+ },
+ }
+ )
+ )
+ );
+ } else if (ev.request.url.includes("nonexistent_worker_script.js")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("postMessage('worker-intercept-success')", {
+ headers: { "Content-Type": "text/javascript" },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("nonexistent_imported_script.js")) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("check_intercepted_script();", {
+ headers: { "Content-Type": "text/javascript" },
+ })
+ )
+ );
+ } else if (ev.request.url.includes("deliver-gzip")) {
+ // Don't handle the request, this will make Necko perform a network request, at
+ // which point SetApplyConversion must be re-enabled, otherwise the request
+ // will fail.
+ return;
+ } else if (ev.request.url.includes("hello.gz")) {
+ ev.respondWith(fetch("fetch/deliver-gzip.sjs"));
+ } else if (ev.request.url.includes("hello-after-extracting.gz")) {
+ ev.respondWith(
+ fetch("fetch/deliver-gzip.sjs").then(function (res) {
+ return res.text().then(function (body) {
+ return new Response(body, {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ });
+ });
+ })
+ );
+ } else if (ev.request.url.includes("opaque-on-same-origin")) {
+ var url =
+ "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
+ ev.respondWith(fetch(url, { mode: "no-cors" }));
+ } else if (ev.request.url.includes("opaque-no-cors")) {
+ if (ev.request.mode != "no-cors") {
+ ev.respondWith(Promise.reject());
+ return;
+ }
+
+ var url =
+ "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
+ ev.respondWith(fetch(url, { mode: ev.request.mode }));
+ } else if (ev.request.url.includes("cors-for-no-cors")) {
+ if (ev.request.mode != "no-cors") {
+ ev.respondWith(Promise.reject());
+ return;
+ }
+
+ var url =
+ "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*";
+ ev.respondWith(fetch(url));
+ } else if (ev.request.url.includes("example.com")) {
+ ev.respondWith(fetch(ev.request));
+ } else if (ev.request.url.includes("body-")) {
+ ev.respondWith(
+ ev.request.text().then(function (body) {
+ return new Response(body + body);
+ })
+ );
+ } else if (ev.request.url.includes("something.txt")) {
+ ev.respondWith(Response.redirect("fetch/somethingelse.txt"));
+ } else if (ev.request.url.includes("somethingelse.txt")) {
+ ev.respondWith(new Response("something else response body", {}));
+ } else if (ev.request.url.includes("redirect_serviceworker.sjs")) {
+ // The redirect_serviceworker.sjs server-side JavaScript file redirects to
+ // 'http://mochi.test:8888/tests/dom/serviceworkers/test/worker.js'
+ // The redirected fetch should not go through the SW since the original
+ // fetch was initiated from a SW.
+ ev.respondWith(fetch("redirect_serviceworker.sjs"));
+ } else if (
+ ev.request.url.includes("load_cross_origin_xml_document_synthetic.xml")
+ ) {
+ ev.respondWith(
+ Promise.resolve(
+ new Response("<response>body</response>", {
+ headers: { "Content-Type": "text/xtml" },
+ })
+ )
+ );
+ } else if (
+ ev.request.url.includes("load_cross_origin_xml_document_cors.xml")
+ ) {
+ if (ev.request.mode != "same-origin") {
+ ev.respondWith(Promise.reject());
+ return;
+ }
+
+ var url =
+ "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200&allowOrigin=*";
+ ev.respondWith(fetch(url, { mode: "cors" }));
+ } else if (
+ ev.request.url.includes("load_cross_origin_xml_document_opaque.xml")
+ ) {
+ if (ev.request.mode != "same-origin") {
+ Promise.resolve(
+ new Response("<error>Invalid Request mode</error>", {
+ headers: { "Content-Type": "text/xtml" },
+ })
+ );
+ return;
+ }
+
+ var url =
+ "http://example.com/tests/dom/security/test/cors/file_CrossSiteXHR_server.sjs?status=200";
+ ev.respondWith(fetch(url, { mode: "no-cors" }));
+ } else if (ev.request.url.includes("xhr-method-test.txt")) {
+ ev.respondWith(new Response("intercepted " + ev.request.method));
+ } else if (ev.request.url.includes("empty-header")) {
+ if (
+ !ev.request.headers.has("emptyheader") ||
+ ev.request.headers.get("emptyheader") !== ""
+ ) {
+ ev.respondWith(Promise.reject());
+ return;
+ }
+ ev.respondWith(new Response("emptyheader"));
+ } else if (ev.request.url.includes("fetchevent-extendable")) {
+ if (ev instanceof ExtendableEvent) {
+ ev.respondWith(new Response("extendable"));
+ } else {
+ ev.respondWith(Promise.reject());
+ }
+ } else if (ev.request.url.includes("fetchevent-request")) {
+ var threw = false;
+ try {
+ new FetchEvent("foo");
+ } catch (e) {
+ if (e.name == "TypeError") {
+ threw = true;
+ }
+ } finally {
+ ev.respondWith(new Response(threw ? "non-nullable" : "nullable"));
+ }
+ }
+};