worker-interception-redirect.https.html

<!DOCTYPE html>

<title>Service Worker: controlling Worker/SharedWorker</title>

<meta name="timeout" content="long">

<script src="/resources/testharness.js"></script>

<script src="/resources/testharnessreport.js"></script>

<script src="resources/test-helpers.sub.js"></script>

<body>

<script>

// This tests service worker interception for worker clients, when the request

// for the worker script goes through redirects. For example, a request can go

// through a chain of URLs like A -> B -> C -> D and each URL might fall in the

// scope of a different service worker, if any.

// The two key questions are:

// 1. Upon a redirect from A -> B, should a service worker for scope B

//    intercept the request?

// 2. After the final response, which service worker controls the resulting

//    client?

//

// The standard prescribes the following:

// 1. The service worker for scope B intercepts the redirect. *However*, once a

//    request falls back to network (i.e., a service worker did not call

//    respondWith()) and a redirect is then received from network, no service

//    worker should intercept that redirect or any subsequent redirects.

// 2. The final service worker that got a fetch event (or would have, in the

//    case of a non-fetch-event worker) becomes the controller of the client.

//

// The standard may change later, see:

// https://github.com/w3c/ServiceWorker/issues/1289

//

// The basic test setup is:

// 1. Page registers service workers for scope1 and scope2.

// 2. Page requests a worker from scope1.

// 3. The request is redirected to scope2 or out-of-scope.

// 4. The worker posts message to the page describing where the final response

//   was served from (service worker or network).

// 5. The worker does an importScripts() and fetch(), and posts back the

//   responses, which describe where the responses where served from.

// Globals for easier cleanup.

const scope1 = 'resources/scope1';

const scope2 = 'resources/scope2';

let frame;

function get_message_from_worker(port) {

  return new Promise(resolve => {

      port.onmessage = evt => {

        resolve(evt.data);

});

async function cleanup() {

  if (frame)

    frame.remove();

  const reg1 = await navigator.serviceWorker.getRegistration(scope1);

  if (reg1)

    await reg1.unregister();

  const reg2 = await navigator.serviceWorker.getRegistration(scope2);

  if (reg2)

    await reg2.unregister();

// Builds the worker script URL, which encodes information about where

// to redirect to. The URL falls in sw1's scope.

//

// - |redirector| is "network" or "serviceworker". If "serviceworker", sw1 will

// respondWith() a redirect. Otherwise, it falls back to network and the server

// responds with a redirect.

// - |redirect_location| is "scope2" or "out-of-scope". If "scope2", the

// redirect ends up in sw2's scope2. Otherwise it's out of scope.

function build_worker_url(redirector, redirect_location) {

  let redirect_path;

  // Set path to redirect.py, a file on the server that serves

  // a redirect. When sw1 sees this URL, it falls back to network.

  if (redirector == 'network')

    redirector_path = 'redirect.py';

  // Set path to 'sw-redirect', to tell the service worker

  // to respond with redirect.

  else if (redirector == 'serviceworker')

    redirector_path = 'sw-redirect';

  let redirect_to = base_path() + 'resources/';

  // Append "scope2/" to redirect_to, so the redirect falls in scope2.

  // Otherwise no change is needed, as the parent "resources/" directory is

  // used, and is out-of-scope.

  if (redirect_location == 'scope2')

    redirect_to += 'scope2/';

  // Append the name of the file which serves the worker script.

  redirect_to += 'worker_interception_redirect_webworker.py';

  return `scope1/${redirector_path}?Redirect=${redirect_to}`

promise_test(async t => {

  await cleanup();

  const service_worker = 'resources/worker-interception-redirect-serviceworker.js';

  const registration1 = await navigator.serviceWorker.register(service_worker, {scope: scope1});

  await wait_for_state(t, registration1.installing, 'activated');

  const registration2 = await navigator.serviceWorker.register(service_worker, {scope: scope2});

  await wait_for_state(t, registration2.installing, 'activated');

  promise_test(t => {

    return cleanup();

  }, 'cleanup global state');

}, 'initialize global state');

async function worker_redirect_test(worker_request_url,

                              worker_expected_url,

                              expected_main_resource_message,

                              expected_import_scripts_message,

                              expected_fetch_message,

                              description) {

  for (const workerType of ['DedicatedWorker', 'SharedWorker']) {

    for (const type of ['classic', 'module']) {

      promise_test(async t => {

        // Create a frame to load the worker from. This way we can remove the

        // frame to destroy the worker client when the test is done.

        frame = await with_iframe('resources/blank.html');

        t.add_cleanup(() => { frame.remove(); });

        // Start the worker.

        let w;

        let port;

        if (workerType === 'DedicatedWorker') {

          w = new frame.contentWindow.Worker(worker_request_url, {type});

          port = w;

        } else {

          w = new frame.contentWindow.SharedWorker(worker_request_url, {type});

          port = w.port;

          w.port.start();

        w.onerror = t.unreached_func('Worker error');

        // Expect a message from the worker indicating which service worker

        // provided the response for the worker script request, if any.

        const data = await get_message_from_worker(port);

        // The worker does an importScripts(). Expect a message from the worker

        // indicating which service worker provided the response for the

        // importScripts(), if any.

        const import_scripts_message = await get_message_from_worker(port);

        test(() => {

          if (type === 'classic') {

            assert_equals(import_scripts_message,

                          expected_import_scripts_message);

          } else {

            assert_equals(import_scripts_message, 'importScripts failed');

        }, `${description} (${type} ${workerType}, importScripts())`);

        // The worker does a fetch(). Expect a message from the worker

        // indicating which service worker provided the response for the

        // fetch(), if any.

        const fetch_message = await get_message_from_worker(port);

        test(() => {

          assert_equals(fetch_message, expected_fetch_message);

        }, `${description} (${type} ${workerType}, fetch())`);

        // Expect a message from the worker indicating |self.location|.

        const worker_actual_url = await get_message_from_worker(port);

        test(() => {

          assert_equals(

            worker_actual_url,

            (new URL(worker_expected_url, location.href)).toString(),

            'location.href');

        }, `${description} (${type} ${workerType}, location.href)`);

        assert_equals(data, expected_main_resource_message);

      }, `${description} (${type} ${workerType})`);

// request to sw1 scope gets network redirect to sw2 scope

worker_redirect_test(

    build_worker_url('network', 'scope2'),

    'resources/scope2/worker_interception_redirect_webworker.py',

    'the worker script was served from network',

    'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/scope2/import-scripts-echo.py',

    'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/scope2/simple.txt',

    'Case #1: network scope1->scope2');

// request to sw1 scope gets network redirect to out-of-scope

worker_redirect_test(

    build_worker_url('network', 'out-scope'),

    'resources/worker_interception_redirect_webworker.py',

    'the worker script was served from network',

    'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/import-scripts-echo.py',

    'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/simple.txt',

    'Case #2: network scope1->out-scope');

// request to sw1 scope gets service-worker redirect to sw2 scope

worker_redirect_test(

    build_worker_url('serviceworker', 'scope2'),

    'resources/subdir/worker_interception_redirect_webworker.py?greeting=sw2%20saw%20the%20request%20for%20the%20worker%20script',

    'sw2 saw the request for the worker script',

    'sw2 saw importScripts from the worker: /service-workers/service-worker/resources/subdir/import-scripts-echo.py',

    'fetch(): sw2 saw the fetch from the worker: /service-workers/service-worker/resources/subdir/simple.txt',

    'Case #3: sw scope1->scope2');

// request to sw1 scope gets service-worker redirect to out-of-scope

worker_redirect_test(

    build_worker_url('serviceworker', 'out-scope'),

    'resources/worker_interception_redirect_webworker.py',

    'the worker script was served from network',

    'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/import-scripts-echo.py',

    'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/simple.txt',

    'Case #4: sw scope1->out-scope');

</script>

</body>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings