update-import-scripts.https.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 5 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /service-workers/service-worker/update-import-scripts.https.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<meta charset="utf-8">

<title>Tests for importScripts: import scripts ignored error</title>

<script src="/common/utils.js"></script>

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

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

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

<body>

<script>

// This file contains tests to check if imported scripts appropriately updated.

const SCOPE = 'resources/simple.txt';

// Create a service worker (update-worker-from-file.py), which is initially

// |initial_worker| and |updated_worker| later.

async function prepare_ready_update_worker_from_file(

    t, initial_worker, updated_worker) {

  const key = token();

  const worker_url = `resources/update-worker-from-file.py?` +

      `First=${initial_worker}&Second=${updated_worker}&Key=${key}`;

  const expected_url = normalizeURL(worker_url);

  const registration = await service_worker_unregister_and_register(

      t, worker_url, SCOPE);

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

  assert_equals(registration.installing, null,

                'prepare_ready: installing');

  assert_equals(registration.waiting, null,

                'prepare_ready: waiting');

  assert_equals(registration.active.scriptURL, expected_url,

                'prepare_ready: active');

  return [registration, expected_url];

// Create a service worker using the script under resources/.

async function prepare_ready_normal_worker(t, filename, additional_params='') {

  const key = token();

  const worker_url = `resources/${filename}?Key=${key}&${additional_params}`;

  const expected_url = normalizeURL(worker_url);

  const registration = await service_worker_unregister_and_register(

      t, worker_url, SCOPE);

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

  assert_equals(registration.installing, null,

                'prepare_ready: installing');

  assert_equals(registration.waiting, null,

                'prepare_ready: waiting');

  assert_equals(registration.active.scriptURL, expected_url,

                'prepare_ready: active');

  return [registration, expected_url];

function assert_installing_and_active(registration, expected_url) {

  assert_equals(registration.installing.scriptURL, expected_url,

                'assert_installing_and_active: installing');

  assert_equals(registration.waiting, null,

                'assert_installing_and_active: waiting');

  assert_equals(registration.active.scriptURL, expected_url,

                'assert_installing_and_active: active');

function assert_waiting_and_active(registration, expected_url) {

  assert_equals(registration.installing, null,

                'assert_waiting_and_active: installing');

  assert_equals(registration.waiting.scriptURL, expected_url,

                'assert_waiting_and_active: waiting');

  assert_equals(registration.active.scriptURL, expected_url,

                'assert_waiting_and_active: active');

function assert_active_only(registration, expected_url) {

  assert_equals(registration.installing, null,

                'assert_active_only: installing');

  assert_equals(registration.waiting, null,

                'assert_active_only: waiting');

  assert_equals(registration.active.scriptURL, expected_url,

                'assert_active_only: active');

promise_test(async t => {

  const [registration, expected_url] =

      await prepare_ready_update_worker_from_file(

          t, 'empty.js', 'import-scripts-404.js');

  t.add_cleanup(() => registration.unregister());

  await promise_rejects_js(t, TypeError, registration.update());

  assert_active_only(registration, expected_url);

}, 'update() should fail when a new worker imports an unavailable script.');

promise_test(async t => {

  const [registration, expected_url] =

      await prepare_ready_update_worker_from_file(

          t, 'import-scripts-404-after-update.js', 'empty.js');

  t.add_cleanup(() => registration.unregister());

  await Promise.all([registration.update(), wait_for_update(t, registration)]);

  assert_installing_and_active(registration, expected_url);

  await wait_for_state(t, registration.installing, 'installed');

  assert_waiting_and_active(registration, expected_url);

  await wait_for_state(t, registration.waiting, 'activated');

  assert_active_only(registration, expected_url);

}, 'update() should succeed when the old imported script no longer exist but ' +

   "the new worker doesn't import it.");

promise_test(async t => {

  const [registration, expected_url] = await prepare_ready_normal_worker(

    t, 'import-scripts-404-after-update.js');

  t.add_cleanup(() => registration.unregister());

  await registration.update();

  assert_active_only(registration, expected_url);

}, 'update() should treat 404 on imported scripts as no change.');

promise_test(async t => {

  const [registration, expected_url] = await prepare_ready_normal_worker(

    t, 'import-scripts-404-after-update-plus-update-worker.js',

       `AdditionalKey=${token()}`);

  t.add_cleanup(() => registration.unregister());

  await promise_rejects_js(t, TypeError, registration.update());

  assert_active_only(registration, expected_url);

}, 'update() should find an update in an imported script but update() should ' +

   'result in failure due to missing the other imported script.');

promise_test(async t => {

  const [registration, expected_url] = await prepare_ready_normal_worker(

    t, 'import-scripts-cross-origin-worker.sub.js');

  t.add_cleanup(() => registration.unregister());

  await registration.update();

  assert_installing_and_active(registration, expected_url);

}, 'update() should work with cross-origin importScripts.');

</script>

</body>