fetch/metadata/generated/element-a.https.sub.html - external/github.com/web-platform-tests/wpt - Git at Google

 <!DOCTYPE html>
 <!--
 This test was procedurally generated. Please do not modify it directly.
 Sources:
 - fetch/metadata/tools/fetch-metadata.conf.yml
 - fetch/metadata/tools/templates/element-a.sub.html
 -->
 <html lang="en">
   <meta charset="utf-8">
   <meta name="timeout" content="long">
   <title>HTTP headers on request for HTML "a" element navigation</title>
   <script src="/resources/testharness.js"></script>
   <script src="/resources/testharnessreport.js"></script>
   <script src="/resources/testdriver.js"></script>
   <script src="/resources/testdriver-vendor.js"></script>
   <script src="/fetch/metadata/resources/helper.sub.js"></script>
   <body>
   <script>
   'use strict';

   function induceRequest(url, {test, userActivated, attributes}) {
     const win = window.open();
     const anchor = win.document.createElement('a');
     anchor.setAttribute('href', url);

     for (const [ name, value ] of Object.entries(attributes)) {
       anchor.setAttribute(name, value);
     }

     win.document.body.appendChild(anchor);

     test.add_cleanup(() => win.close());

     if (userActivated) {
       test_driver.bless('enable user activation', () => anchor.click());
     } else {
       anchor.click();
     }
   }

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
         });
   }, 'sec-fetch-site - Same origin - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsCrossSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Cross-site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsSameSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-site']);
         });
   }, 'sec-fetch-site - Same site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Same-Origin -> Cross-Site -> Same-Origin redirect - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpsSameSite', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-site']);
         });
   }, 'sec-fetch-site - Same-Origin -> Same-Site -> Same-Origin redirect - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsCrossSite', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Cross-Site -> Same Origin - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsCrossSite', 'httpsSameSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Cross-Site -> Same-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsCrossSite', 'httpsCrossSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Cross-Site -> Cross-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
         });
   }, 'sec-fetch-site - Same-Origin -> Same Origin - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpsSameSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-site']);
         });
   }, 'sec-fetch-site - Same-Origin -> Same-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Same-Origin -> Cross-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsSameSite', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-site']);
         });
   }, 'sec-fetch-site - Same-Site -> Same Origin - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsSameSite', 'httpsSameSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['same-site']);
         });
   }, 'sec-fetch-site - Same-Site -> Same-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsSameSite', 'httpsCrossSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - Same-Site -> Cross-Site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsOrigin', 'httpOrigin', 'httpsOrigin'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-site');
           assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
         });
   }, 'sec-fetch-site - HTTPS downgrade-upgrade - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-mode');
           assert_array_equals(headers['sec-fetch-mode'], ['navigate']);
         });
   }, 'sec-fetch-mode - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {"download": ""}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-mode');
           assert_array_equals(headers['sec-fetch-mode'], ['no-cors']);
         });
   }, 'sec-fetch-mode - attributes: download');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-dest');
           assert_array_equals(headers['sec-fetch-dest'], ['document']);
         });
   }, 'sec-fetch-dest - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {"download": ""}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-dest');
           assert_array_equals(headers['sec-fetch-dest'], ['empty']);
         });
   }, 'sec-fetch-dest - attributes: download');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_not_own_property(headers, 'sec-fetch-user');
         });
   }, 'sec-fetch-user - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, [], {mime: 'text/html'}),
       {
         test: t,
         userActivated: true,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_own_property(headers, 'sec-fetch-user');
           assert_array_equals(headers['sec-fetch-user'], ['?1']);
         });
   }, 'sec-fetch-user - no attributes with user activation');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsCrossSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_not_own_property(headers, 'sec-fetch-storage-access');
         });
   }, 'sec-fetch-storage-access - Cross-site - no attributes');

   promise_test((t) => {
     const key = '{{uuid()}}';

     induceRequest(
       makeRequestURL(key, ['httpsSameSite'], {mime: 'text/html'}),
       {
         test: t,
         userActivated: false,
         attributes: {}
       }
     );

     // `induceRequest` does not necessarily trigger a navigation, so the Python
     // handler must be polled until it has received the initial request.
     return retrieve(key, {poll: true})
       .then((headers) => {
           assert_not_own_property(headers, 'sec-fetch-storage-access');
         });
   }, 'sec-fetch-storage-access - Same site - no attributes');
   </script>
   </body>
 </html>
	<!DOCTYPE html>
	<!--
	This test was procedurally generated. Please do not modify it directly.
	Sources:
	- fetch/metadata/tools/fetch-metadata.conf.yml
	- fetch/metadata/tools/templates/element-a.sub.html
	-->
	<html lang="en">
	<meta charset="utf-8">
	<meta name="timeout" content="long">
	<title>HTTP headers on request for HTML "a" element navigation</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="/resources/testdriver.js"></script>
	<script src="/resources/testdriver-vendor.js"></script>
	<script src="/fetch/metadata/resources/helper.sub.js"></script>
	<body>
	<script>
	'use strict';

	function induceRequest(url, {test, userActivated, attributes}) {
	const win = window.open();
	const anchor = win.document.createElement('a');
	anchor.setAttribute('href', url);

	for (const [ name, value ] of Object.entries(attributes)) {
	anchor.setAttribute(name, value);
	}

	win.document.body.appendChild(anchor);

	test.add_cleanup(() => win.close());

	if (userActivated) {
	test_driver.bless('enable user activation', () => anchor.click());
	} else {
	anchor.click();
	}
	}

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
	});
	}, 'sec-fetch-site - Same origin - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsCrossSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Cross-site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsSameSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-site']);
	});
	}, 'sec-fetch-site - Same site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Same-Origin -> Cross-Site -> Same-Origin redirect - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpsSameSite', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-site']);
	});
	}, 'sec-fetch-site - Same-Origin -> Same-Site -> Same-Origin redirect - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsCrossSite', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Cross-Site -> Same Origin - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsCrossSite', 'httpsSameSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Cross-Site -> Same-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsCrossSite', 'httpsCrossSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Cross-Site -> Cross-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-origin']);
	});
	}, 'sec-fetch-site - Same-Origin -> Same Origin - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpsSameSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-site']);
	});
	}, 'sec-fetch-site - Same-Origin -> Same-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpsCrossSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Same-Origin -> Cross-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsSameSite', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-site']);
	});
	}, 'sec-fetch-site - Same-Site -> Same Origin - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsSameSite', 'httpsSameSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['same-site']);
	});
	}, 'sec-fetch-site - Same-Site -> Same-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsSameSite', 'httpsCrossSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - Same-Site -> Cross-Site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsOrigin', 'httpOrigin', 'httpsOrigin'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-site');
	assert_array_equals(headers['sec-fetch-site'], ['cross-site']);
	});
	}, 'sec-fetch-site - HTTPS downgrade-upgrade - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-mode');
	assert_array_equals(headers['sec-fetch-mode'], ['navigate']);
	});
	}, 'sec-fetch-mode - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {"download": ""}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-mode');
	assert_array_equals(headers['sec-fetch-mode'], ['no-cors']);
	});
	}, 'sec-fetch-mode - attributes: download');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-dest');
	assert_array_equals(headers['sec-fetch-dest'], ['document']);
	});
	}, 'sec-fetch-dest - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {"download": ""}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-dest');
	assert_array_equals(headers['sec-fetch-dest'], ['empty']);
	});
	}, 'sec-fetch-dest - attributes: download');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_not_own_property(headers, 'sec-fetch-user');
	});
	}, 'sec-fetch-user - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, [], {mime: 'text/html'}),
	{
	test: t,
	userActivated: true,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_own_property(headers, 'sec-fetch-user');
	assert_array_equals(headers['sec-fetch-user'], ['?1']);
	});
	}, 'sec-fetch-user - no attributes with user activation');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsCrossSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_not_own_property(headers, 'sec-fetch-storage-access');
	});
	}, 'sec-fetch-storage-access - Cross-site - no attributes');

	promise_test((t) => {
	const key = '{{uuid()}}';

	induceRequest(
	makeRequestURL(key, ['httpsSameSite'], {mime: 'text/html'}),
	{
	test: t,
	userActivated: false,
	attributes: {}
	}
	);

	// `induceRequest` does not necessarily trigger a navigation, so the Python
	// handler must be polled until it has received the initial request.
	return retrieve(key, {poll: true})
	.then((headers) => {
	assert_not_own_property(headers, 'sec-fetch-storage-access');
	});
	}, 'sec-fetch-storage-access - Same site - no attributes');
	</script>
	</body>
	</html>