background-sync.https.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 10 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /fenced-frame/background-sync.https.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<title>Test fenced frame does not allow to register background sync</title>

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

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

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

<script src="/common/get-host-info.sub.js"></script>

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

<body>

<script>

const background_sync_register_key = token();

const fenced_frame_url = 'resources/background-sync-inner.https.html';

const fenced_frame_url_for_service_worker_test =

  'resources/background-sync-sw-inner.https.html';

const generateFencedFrameUrl = (params, is_worker_test = false) => {

  const searchParams = new URLSearchParams(params);

  const frame_url = is_worker_test ?

    fenced_frame_url_for_service_worker_test : fenced_frame_url;

  return generateURL(`${frame_url}?${searchParams.toString()}`,

    [background_sync_register_key]);

};

async function background_sync_test(url, expected_text, message) {

  attachFencedFrame(url)

  // Get the result for the top-level fenced frame.

  const fenced_frame_result =

      await nextValueFromServer(background_sync_register_key);

  assert_equals(fenced_frame_result, expected_text, message);

};

const background_sync_message =

  "Background Sync is not allowed in fenced frames.";

const periodic_background_sync_message =

  "Periodic Background Sync is not allowed in fenced frames.";

promise_test(async (t) => {

  const method = 'register';

  const frame_url = generateFencedFrameUrl({method});

  const expected_message = "Failed to execute 'register' on 'SyncManager': " +

    background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'register() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'register() is disallowed inside a cross-origin fenced frame');

}, 'background sync register');

promise_test(async (t) => {

  const method = 'getTags';

  const frame_url = generateFencedFrameUrl({method});

  const expected_message = background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'getTags() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'getTags() is disallowed inside a cross-origin fenced frame');

}, 'background sync getTags');

promise_test(async (t) => {

  const method = 'register';

  const frame_url = generateFencedFrameUrl({method}, true);

  const expected_message = "Failed to execute 'register' on 'SyncManager': " +

    background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'register() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'register() is disallowed inside a cross-origin fenced frame');

}, 'background sync register in service worker');

promise_test(async (t) => {

  const method = 'getTags';

  const frame_url = generateFencedFrameUrl({method}, true);

  const expected_message = background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'getTags() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'getTags() is disallowed inside a cross-origin fenced frame');

}, 'background sync getTags in service worker');

promise_test(async (t) => {

  const params = {

    method: 'register',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params)

  const expected_message = "Failed to execute 'register' on " +

    "'PeriodicSyncManager': " + periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'register() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'register() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync register');

promise_test(async (t) => {

  const params = {

    method: 'getTags',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params)

  const expected_message = periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'getTags() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'getTags() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync getTags');

promise_test(async (t) => {

  const params = {

    method: 'unregister',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params)

  const expected_message = periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'unregister() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'unregister() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync unregister');

promise_test(async (t) => {

  const params = {

    method: 'register',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params, true)

  const expected_message = "Failed to execute 'register' on " +

    "'PeriodicSyncManager': " + periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'register() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'register() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync register in service worker');

promise_test(async (t) => {

  const params = {

    method: 'getTags',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params, true)

  const expected_message = periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'getTags() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'getTags() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync getTags in service worker');

promise_test(async (t) => {

  const params = {

    method: 'unregister',

    periodic: true

};

  const frame_url = generateFencedFrameUrl(params, true)

  const expected_message = periodic_background_sync_message;

  await background_sync_test(

      frame_url,

      expected_message,

      'unregister() is disallowed inside a same-origin fenced frame');

  const cross_origin_frame_url = getRemoteOriginURL(frame_url);

  await background_sync_test(

      cross_origin_frame_url,

      expected_message,

      'unregister() is disallowed inside a cross-origin fenced frame');

}, 'periodic sync unregister in service worker');

</script>

</body>