ready.https.window.js

mozilla-central/testing/web-platform/tests/service-workers/service-worker/ready.https.window.js (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: DOM: Service Workers

Revision control

Copy as Markdown

Other Tools

Test Info:

This WPT test may be referenced by the following Test IDs:
- /service-workers/service-worker/ready.https.window.html - WPT Dashboard Interop Dashboard

// META: title=Service Worker: navigator.serviceWorker.ready

// META: script=resources/test-helpers.sub.js

test(() => {

  assert_equals(

    navigator.serviceWorker.ready,

    navigator.serviceWorker.ready,

    'repeated access to ready without intervening registrations should return the same Promise object'

);

}, 'ready returns the same Promise object');

promise_test(async t => {

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

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

  const promise = frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(

    Object.getPrototypeOf(promise),

    frame.contentWindow.Promise.prototype,

    'the Promise should be in the context of the related document'

);

}, 'ready returns a Promise object in the context of the related document');

promise_test(async t => {

  const url = 'resources/empty-worker.js';

  const scope = 'resources/blank.html?ready-controlled';

  const expectedURL = normalizeURL(url);

  const registration = await service_worker_unregister_and_register(t, url, scope);

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

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

  const frame = await with_iframe(scope);

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

  const readyReg = await frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(readyReg.installing, null, 'installing should be null');

  assert_equals(readyReg.waiting, null, 'waiting should be null');

  assert_equals(readyReg.active.scriptURL, expectedURL, 'active after ready should not be null');

  assert_equals(

    frame.contentWindow.navigator.serviceWorker.controller,

    readyReg.active,

    'the controller should be the active worker'

);

  assert_in_array(

    readyReg.active.state,

    ['activating', 'activated'],

    '.ready should be resolved when the registration has an active worker'

);

}, 'ready on a controlled document');

promise_test(async t => {

  const url = 'resources/empty-worker.js';

  const scope = 'resources/blank.html?ready-potential-controlled';

  const expected_url = normalizeURL(url);

  const frame = await with_iframe(scope);

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

  const registration = await navigator.serviceWorker.register(url, { scope });

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

  const readyReg = await frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(readyReg.installing, null, 'installing should be null');

  assert_equals(readyReg.waiting, null, 'waiting should be null.')

  assert_equals(readyReg.active.scriptURL, expected_url, 'active after ready should not be null');

  assert_in_array(

    readyReg.active.state,

    ['activating', 'activated'],

    '.ready should be resolved when the registration has an active worker'

);

  assert_equals(

    frame.contentWindow.navigator.serviceWorker.controller,

    null,

    'uncontrolled document should not have a controller'

);

}, 'ready on a potential controlled document');

promise_test(async t => {

  const url = 'resources/empty-worker.js';

  const scope = 'resources/blank.html?ready-installing';

  await service_worker_unregister(t, scope);

  const frame = await with_iframe(scope);

  const promise = frame.contentWindow.navigator.serviceWorker.ready;

  navigator.serviceWorker.register(url, { scope });

  const registration = await promise;

  t.add_cleanup(async () => {

    await registration.unregister();

    frame.remove();

});

  assert_equals(registration.installing, null, 'installing should be null');

  assert_equals(registration.waiting, null, 'waiting should be null');

  assert_not_equals(registration.active, null, 'active after ready should not be null');

  assert_in_array(

    registration.active.state,

    ['activating', 'activated'],

    '.ready should be resolved when the registration has an active worker'

);

}, 'ready on an iframe whose parent registers a new service worker');

promise_test(async t => {

  const scope = 'resources/register-iframe.html';

  const frame = await with_iframe(scope);

  const registration = await frame.contentWindow.navigator.serviceWorker.ready;

  t.add_cleanup(async () => {

    await registration.unregister();

    frame.remove();

});

  assert_equals(registration.installing, null, 'installing should be null');

  assert_equals(registration.waiting, null, 'waiting should be null');

  assert_not_equals(registration.active, null, 'active after ready should not be null');

  assert_in_array(

    registration.active.state,

    ['activating', 'activated'],

    '.ready should be resolved with "active worker"'

);

 }, 'ready on an iframe that installs a new service worker');

promise_test(async t => {

  const url = 'resources/empty-worker.js';

  const matchedScope = 'resources/blank.html?ready-after-match';

  const longerMatchedScope = 'resources/blank.html?ready-after-match-longer';

  await service_worker_unregister(t, matchedScope);

  await service_worker_unregister(t, longerMatchedScope);

  const frame = await with_iframe(longerMatchedScope);

  const registration = await navigator.serviceWorker.register(url, { scope: matchedScope });

  t.add_cleanup(async () => {

    await registration.unregister();

    frame.remove();

});

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

  const longerRegistration = await navigator.serviceWorker.register(url, { scope: longerMatchedScope });

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

  const readyReg = await frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(

    readyReg.scope,

    normalizeURL(longerMatchedScope),

    'longer matched registration should be returned'

);

  assert_equals(

    frame.contentWindow.navigator.serviceWorker.controller,

    null,

    'controller should be null'

);

}, 'ready after a longer matched registration registered');

promise_test(async t => {

  const url = 'resources/empty-worker.js';

  const matchedScope = 'resources/blank.html?ready-after-resolve';

  const longerMatchedScope = 'resources/blank.html?ready-after-resolve-longer';

  const registration = await service_worker_unregister_and_register(t, url, matchedScope);

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

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

  const frame = await with_iframe(longerMatchedScope);

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

  const readyReg1 = await frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(

    readyReg1.scope,

    normalizeURL(matchedScope),

    'matched registration should be returned'

);

  const longerReg = await navigator.serviceWorker.register(url, { scope: longerMatchedScope });

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

  const readyReg2 = await frame.contentWindow.navigator.serviceWorker.ready;

  assert_equals(

    readyReg2.scope,

    normalizeURL(matchedScope),

    'ready should only be resolved once'

);

}, 'access ready after it has been resolved');

promise_test(async t => {

  const url1 = 'resources/empty-worker.js';

  const url2 = url1 + '?2';

  const matchedScope = 'resources/blank.html?ready-after-unregister';

  const reg1 = await service_worker_unregister_and_register(t, url1, matchedScope);

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

  await wait_for_state(t, reg1.installing, 'activating');

  const frame = await with_iframe(matchedScope);

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

  await reg1.unregister();

  // Ready promise should be pending, waiting for a new registration to arrive

  const readyPromise = frame.contentWindow.navigator.serviceWorker.ready;

  const reg2 = await navigator.serviceWorker.register(url2, { scope: matchedScope });

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

  const readyReg = await readyPromise;

  // Wait for registration update, since it comes from another global, the states are racy.

  await wait_for_state(t, reg2.installing || reg2.waiting || reg2.active, 'activated');

  assert_equals(readyReg.active.scriptURL, reg2.active.scriptURL, 'Resolves with the second registration');

  assert_not_equals(reg1, reg2, 'Registrations should be different');

}, 'resolve ready after unregistering');