| <!DOCTYPE html> |
| <title>Service Worker: Redirected response</title> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| <script src="/common/get-host-info.sub.js"></script> |
| <script src="resources/test-helpers.sub.js"></script> |
| <script> |
| // Tests redirect behavior. It calls fetch_method(url, fetch_option) and tests |
| // the resulting response against the expected values. It also adds the |
| // response to |cache| and checks the cached response matches the expected |
| // values. |
| // |
| // |options|: a dictionary of parameters for the test |
| // |options.url|: the URL to fetch |
| // |options.fetch_option|: the options passed to |fetch_method| |
| // |options.fetch_method|: the method used to fetch. Useful for testing an |
| // iframe's fetch() vs. this page's fetch(). |
| // |options.expected_type|: The value of response.type |
| // |options.expected_redirected|: The value of response.redirected |
| // |options.expected_intercepted_urls|: The list of intercepted request URLs. |
| function redirected_test(options) { |
| return options.fetch_method.call(null, options.url, options.fetch_option).then(response => { |
| let cloned_response = response.clone(); |
| assert_equals( |
| response.type, options.expected_type, |
| 'The response type of response must match. URL: ' + options.url); |
| assert_equals( |
| cloned_response.type, options.expected_type, |
| 'The response type of cloned response must match. URL: ' + options.url); |
| assert_equals( |
| response.redirected, options.expected_redirected, |
| 'The redirected flag of response must match. URL: ' + options.url); |
| assert_equals( |
| cloned_response.redirected, options.expected_redirected, |
| 'The redirected flag of cloned response must match. URL: ' + options.url); |
| return cache.put(options.url, response); |
| }) |
| .then(_ => cache.match(options.url)) |
| .then(response => { |
| assert_equals( |
| response.type, options.expected_type, |
| 'The response type of response in CacheStorage must match. ' + |
| 'URL: ' + options.url); |
| assert_equals( |
| response.redirected, options.expected_redirected, |
| 'The redirected flag of response in CacheStorage must match. ' + |
| 'URL: ' + options.url); |
| return check_intercepted_urls(options.expected_intercepted_urls); |
| }); |
| } |
| |
| function take_intercepted_urls() { |
| return new Promise((resolve) => { |
| let channel = new MessageChannel(); |
| channel.port1.onmessage = msg => { resolve(msg.data.urls); }; |
| worker.postMessage({port: channel.port2}, [channel.port2]); |
| }); |
| } |
| |
| function check_intercepted_urls(expected_urls) { |
| return take_intercepted_urls().then((urls) => { |
| assert_object_equals(urls, expected_urls, 'Intercepted URLs matching.'); |
| }); |
| } |
| |
| function setup_and_clean() { |
| // To prevent interference from previous tests, take the intercepted URLs from |
| // the service worker. |
| return setup.then(() => take_intercepted_urls()); |
| } |
| |
| |
| let host_info = get_host_info(); |
| const REDIRECT_URL = host_info['HTTPS_ORIGIN'] + base_path() + |
| 'resources/redirect.py?Redirect='; |
| const TARGET_URL = host_info['HTTPS_ORIGIN'] + base_path() + |
| 'resources/simple.txt?'; |
| const REDIRECT_TO_TARGET_URL = REDIRECT_URL + encodeURIComponent(TARGET_URL); |
| let frame; |
| let cache; |
| let setup; |
| let worker; |
| |
| promise_test(t => { |
| const SCOPE = 'resources/blank.html?redirected-response'; |
| const SCRIPT = 'resources/redirect-worker.js'; |
| const CACHE_NAME = 'service-workers/service-worker/redirected-response'; |
| setup = service_worker_unregister_and_register(t, SCRIPT, SCOPE) |
| .then(registration => { |
| promise_test( |
| () => registration.unregister(), |
| 'restore global state (service worker registration)'); |
| worker = registration.installing; |
| return wait_for_state(t, registration.installing, 'activated'); |
| }) |
| .then(_ => self.caches.open(CACHE_NAME)) |
| .then(c => { |
| cache = c; |
| promise_test( |
| () => self.caches.delete(CACHE_NAME), |
| 'restore global state (caches)'); |
| return with_iframe(SCOPE); |
| }) |
| .then(f => { |
| frame = f; |
| add_completion_callback(() => f.remove()); |
| return check_intercepted_urls( |
| [host_info['HTTPS_ORIGIN'] + base_path() + SCOPE]); |
| }); |
| return setup; |
| }, 'initialize global state (service worker registration and caches)'); |
| |
| // =============================================================== |
| // Tests for requests that are out-of-scope of the service worker. |
| // =============================================================== |
| promise_test(t => setup_and_clean() |
| .then(() => redirected_test({url: TARGET_URL, |
| fetch_option: {}, |
| fetch_method: self.fetch, |
| expected_type: 'basic', |
| expected_redirected: false, |
| expected_intercepted_urls: []})), |
| 'mode: "follow", non-intercepted request, no server redirect'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => redirected_test({url: REDIRECT_TO_TARGET_URL, |
| fetch_option: {}, |
| fetch_method: self.fetch, |
| expected_type: 'basic', |
| expected_redirected: true, |
| expected_intercepted_urls: []})), |
| 'mode: "follow", non-intercepted request'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => redirected_test({url: REDIRECT_TO_TARGET_URL + '&manual', |
| fetch_option: {redirect: 'manual'}, |
| fetch_method: self.fetch, |
| expected_type: 'opaqueredirect', |
| expected_redirected: false, |
| expected_intercepted_urls: []})), |
| 'mode: "manual", non-intercepted request'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => promise_rejects( |
| t, new TypeError(), |
| self.fetch(REDIRECT_TO_TARGET_URL + '&error', |
| {redirect:'error'}), |
| 'The redirect response from the server should be treated as' + |
| ' an error when the redirect flag of request was \'error\'.')) |
| .then(() => check_intercepted_urls([])), |
| 'mode: "error", non-intercepted request'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = TARGET_URL + '&sw=fetch'; |
| return redirected_test({url: url, |
| fetch_option: {}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'basic', |
| expected_redirected: false, |
| expected_intercepted_urls: [url]}) |
| }), |
| 'mode: "follow", no mode change, no server redirect'); |
| |
| // ======================================================= |
| // Tests for requests that are in-scope of the service worker. The service |
| // worker returns a redirected response. |
| // ======================================================= |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=follow&sw=fetch'; |
| return redirected_test({url: url, |
| fetch_option: {redirect: 'follow'}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'basic', |
| expected_redirected: true, |
| expected_intercepted_urls: [url]}) |
| }), |
| 'mode: "follow", no mode change'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=error&sw=follow'; |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(url, {redirect: 'error'}), |
| 'The redirected response from the service worker should be ' + |
| 'treated as an error when the redirect flag of request was ' + |
| '\'error\'.') |
| .then(() => check_intercepted_urls([url])); |
| }), |
| 'mode: "error", mode change: "follow"'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=manual&sw=follow'; |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(url, {redirect: 'manual'}), |
| 'The redirected response from the service worker should be ' + |
| 'treated as an error when the redirect flag of request was ' + |
| '\'manual\'.') |
| .then(() => check_intercepted_urls([url])); |
| }), |
| 'mode: "manual", mode change: "follow"'); |
| |
| // ======================================================= |
| // Tests for requests that are in-scope of the service worker. The service |
| // worker returns an opaqueredirect response. |
| // ======================================================= |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=follow&sw=manual'; |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(url, {redirect: 'follow'}), |
| 'The opaqueredirect response from the service worker should ' + |
| 'be treated as an error when the redirect flag of request was' + |
| ' \'follow\'.') |
| .then(() => check_intercepted_urls([url])); |
| }), |
| 'mode: "follow", mode change: "manual"'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=error&sw=manual'; |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(url, {redirect: 'error'}), |
| 'The opaqueredirect response from the service worker should ' + |
| 'be treated as an error when the redirect flag of request was' + |
| ' \'error\'.') |
| .then(() => check_intercepted_urls([url])); |
| }), |
| 'mode: "error", mode change: "manual"'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = REDIRECT_TO_TARGET_URL + |
| '&original-redirect-mode=manual&sw=manual'; |
| return redirected_test({url: url, |
| fetch_option: {redirect: 'manual'}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'opaqueredirect', |
| expected_redirected: false, |
| expected_intercepted_urls: [url]}); |
| }), |
| 'mode: "manual", no mode change'); |
| |
| // ======================================================= |
| // Tests for requests that are in-scope of the service worker. The service |
| // worker returns a generated redirect response. |
| // ======================================================= |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = host_info['HTTPS_ORIGIN'] + base_path() + |
| 'dummy?url=' + encodeURIComponent(TARGET_URL) + |
| '&original-redirect-mode=follow&sw=gen'; |
| return redirected_test({url: url, |
| fetch_option: {redirect: 'follow'}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'basic', |
| expected_redirected: true, |
| expected_intercepted_urls: [url, TARGET_URL]}) |
| }), |
| 'mode: "follow", generated redirect response'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = host_info['HTTPS_ORIGIN'] + base_path() + |
| 'dummy?url=' + encodeURIComponent(TARGET_URL) + |
| '&original-redirect-mode=error&sw=gen'; |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(url, {redirect: 'error'}), |
| 'The generated redirect response from the service worker should ' + |
| 'be treated as an error when the redirect flag of request was' + |
| ' \'error\'.') |
| .then(() => check_intercepted_urls([url])); |
| }), |
| 'mode: "error", generated redirect response'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| const url = host_info['HTTPS_ORIGIN'] + base_path() + |
| 'dummy?url=' + encodeURIComponent(TARGET_URL) + |
| '&original-redirect-mode=follow&sw=gen'; |
| return redirected_test({url: url, |
| fetch_option: {redirect: 'manual'}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'opaqueredirect', |
| expected_redirected: false, |
| expected_intercepted_urls: [url]}) |
| }), |
| 'mode: "manual", generated redirect response'); |
| |
| // ======================================================= |
| // Tests for requests that are in-scope of the service worker. The service |
| // worker returns a generated redirect response. And the fetch follows the |
| // redirection multiple times. |
| // ======================================================= |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| // The Fetch spec says: "If request’s redirect count is twenty, return a |
| // network error." https://fetch.spec.whatwg.org/#http-redirect-fetch |
| // So fetch can follow the redirect response 20 times. |
| let urls = [TARGET_URL]; |
| for (let i = 0; i < 20; ++i) { |
| urls.unshift(host_info['HTTPS_ORIGIN'] + '/dummy?sw=gen&url=' + |
| encodeURIComponent(urls[0])); |
| |
| } |
| return redirected_test({url: urls[0], |
| fetch_option: {redirect: 'follow'}, |
| fetch_method: frame.contentWindow.fetch, |
| expected_type: 'basic', |
| expected_redirected: true, |
| expected_intercepted_urls: urls}) |
| }), |
| 'Fetch should follow the redirect response 20 times'); |
| |
| promise_test(t => setup_and_clean() |
| .then(() => { |
| let urls = [TARGET_URL]; |
| // The Fetch spec says: "If request’s redirect count is twenty, return a |
| // network error." https://fetch.spec.whatwg.org/#http-redirect-fetch |
| // So fetch can't follow the redirect response 21 times. |
| for (let i = 0; i < 21; ++i) { |
| urls.unshift(host_info['HTTPS_ORIGIN'] + '/dummy?sw=gen&url=' + |
| encodeURIComponent(urls[0])); |
| |
| } |
| return promise_rejects( |
| t, new TypeError(), |
| frame.contentWindow.fetch(urls[0], {redirect: 'follow'}), |
| 'Fetch should not follow the redirect response 21 times.') |
| .then(() => { |
| urls.pop(); |
| return check_intercepted_urls(urls) |
| }); |
| }), |
| 'Fetch should not follow the redirect response 21 times.'); |
| </script> |