speculation-rules/prefetch/navigation-timing-requestStart-responseStart.https.html - external/github.com/web-platform-tests/wpt - Git at Google

 <!DOCTYPE html>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/common/dispatcher/dispatcher.js"></script>
 <script src="/common/utils.js"></script>
 <script src="../resources/utils.js"></script>
 <script src="resources/utils.sub.js"></script>
 <script src="/common/subset-tests-by-key.js"></script>

 <meta name="variant" content="?include=noPrefetch">
 <meta name="variant" content="?include=afterResponse">
 <meta name="variant" content="?include=waitingForResponse">
 <meta name="variant" content="?include=waitingForRedirect">

 <script>
 const setupProperties = {};
 if (shouldRunSubTest('waitingForResponse') || shouldRunSubTest('waitingForRedirect')) {
   // These tests rely on the relationship between these timeouts, the delays
   // on the server, and any vendor specific timeouts. Force a multiplier of 1,
   // since using setTimeout directly incurs the wrath of `wpt lint`.
   setupProperties.timeout_multiplier = 1;
 }
 setup(() => assertSpeculationRulesIsSupported(), setupProperties);

 subsetTestByKey('noPrefetch', promise_test, async t => {
   const agent = await spawnWindow(t);
   const landingUrl = agent.getExecutorURL({page: 2});

   await agent.navigate(landingUrl);
   assert_not_prefetched(await agent.getRequestHeaders(), `${landingUrl} should not be prefetched.`);

   // It's generally expected that events occur in this order:
   //   ... -> connectEnd --> requestStart --> responseStart --> ...
   const [entry] = await agent.execute_script(
       () => performance.getEntriesByType('navigation'));
   assert_less_than_equal(entry.connectEnd, entry.requestStart);
   assert_less_than_equal(entry.requestStart, entry.responseStart);
 }, "PerformanceNavigationTiming data should be in the correct order (no prefetch)");

 subsetTestByKey('afterResponse', promise_test, async t => {
   const agent = await spawnWindow(t);
   const landingUrl = agent.getExecutorURL({page: 2});
   await agent.forceSinglePrefetch(landingUrl);

   await agent.navigate(landingUrl);
   assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

   // Since the response should have started before the navigation, these should
   // all have the same value (i.e., the start of the fetch).
   const [entry] = await agent.execute_script(
       () => performance.getEntriesByType('navigation'));
   assert_equals(entry.connectEnd, entry.requestStart);
   assert_equals(entry.requestStart, entry.responseStart);
 }, "PerformanceNavigationTiming data should show 'instantaneous' events completed beforehand");

 subsetTestByKey('waitingForResponse', promise_test, async t => {
   const agent = await spawnWindow(t);
   const landingUrl = agent.getExecutorURL({executor: 'slow-executor.py', delay: '4', page: 2});
   await agent.forceSinglePrefetch(landingUrl, {}, /*wait_for_completion=*/false);
   await new Promise(resolve => t.step_timeout(resolve, 1000));

   await agent.navigate(landingUrl);
   assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

   // We should have to wait for this response. While timing is going to be
   // somewhat variable here, it's probably wrong for the response to seem
   // to take less than 1 second (since we only waited for 1 second).
   // Regardless, these events should be normally ordered.
   const [entry] = await agent.execute_script(
       () => performance.getEntriesByType('navigation'));
   assert_less_than_equal(entry.connectEnd, entry.requestStart);
   assert_less_than_equal(entry.requestStart + 1000, entry.responseStart);
   assert_greater_than(entry.responseStart, 1000);
 }, "PerformanceNavigationTiming data should show noticeable TTFB if the response is slow");

 subsetTestByKey('waitingForRedirect', promise_test, async t => {
   const agent = await spawnWindow(t);
   const landingUrl = agent.getExecutorURL({page: 2});
   const slowRedirectUrl = new URL(`/common/slow-redirect.py?delay=4&location=${encodeURIComponent(landingUrl)}`, document.baseURI);
   await agent.forceSinglePrefetch(slowRedirectUrl, {}, /*wait_for_completion=*/false);
   await new Promise(resolve => t.step_timeout(resolve, 1000));

   await agent.navigate(slowRedirectUrl, {expectedDestinationUrl: landingUrl});
   assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

   // We should have to wait for this response. While timing is going to be
   // somewhat variable here, it's probably wrong for the response to seem
   // to take less than 1 second (since we only waited for 1 second).
   // Regardless, these events should be normally ordered.
   const [entry] = await agent.execute_script(
       () => performance.getEntriesByType('navigation'));
   assert_less_than_equal(entry.connectEnd, entry.requestStart);
   assert_less_than_equal(entry.requestStart, entry.responseStart);
   assert_greater_than(entry.responseStart, 1000);
 }, "PerformanceNavigationTiming data should show noticeable TTFB if the response is slow");
 </script>
	<!DOCTYPE html>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="/common/dispatcher/dispatcher.js"></script>
	<script src="/common/utils.js"></script>
	<script src="../resources/utils.js"></script>
	<script src="resources/utils.sub.js"></script>
	<script src="/common/subset-tests-by-key.js"></script>

	<meta name="variant" content="?include=noPrefetch">
	<meta name="variant" content="?include=afterResponse">
	<meta name="variant" content="?include=waitingForResponse">
	<meta name="variant" content="?include=waitingForRedirect">

	<script>
	const setupProperties = {};
	if (shouldRunSubTest('waitingForResponse') \|\| shouldRunSubTest('waitingForRedirect')) {
	// These tests rely on the relationship between these timeouts, the delays
	// on the server, and any vendor specific timeouts. Force a multiplier of 1,
	// since using setTimeout directly incurs the wrath of `wpt lint`.
	setupProperties.timeout_multiplier = 1;
	}
	setup(() => assertSpeculationRulesIsSupported(), setupProperties);

	subsetTestByKey('noPrefetch', promise_test, async t => {
	const agent = await spawnWindow(t);
	const landingUrl = agent.getExecutorURL({page: 2});

	await agent.navigate(landingUrl);
	assert_not_prefetched(await agent.getRequestHeaders(), `${landingUrl} should not be prefetched.`);

	// It's generally expected that events occur in this order:
	// ... -> connectEnd --> requestStart --> responseStart --> ...
	const [entry] = await agent.execute_script(
	() => performance.getEntriesByType('navigation'));
	assert_less_than_equal(entry.connectEnd, entry.requestStart);
	assert_less_than_equal(entry.requestStart, entry.responseStart);
	}, "PerformanceNavigationTiming data should be in the correct order (no prefetch)");

	subsetTestByKey('afterResponse', promise_test, async t => {
	const agent = await spawnWindow(t);
	const landingUrl = agent.getExecutorURL({page: 2});
	await agent.forceSinglePrefetch(landingUrl);

	await agent.navigate(landingUrl);
	assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

	// Since the response should have started before the navigation, these should
	// all have the same value (i.e., the start of the fetch).
	const [entry] = await agent.execute_script(
	() => performance.getEntriesByType('navigation'));
	assert_equals(entry.connectEnd, entry.requestStart);
	assert_equals(entry.requestStart, entry.responseStart);
	}, "PerformanceNavigationTiming data should show 'instantaneous' events completed beforehand");

	subsetTestByKey('waitingForResponse', promise_test, async t => {
	const agent = await spawnWindow(t);
	const landingUrl = agent.getExecutorURL({executor: 'slow-executor.py', delay: '4', page: 2});
	await agent.forceSinglePrefetch(landingUrl, {}, /wait_for_completion=/false);
	await new Promise(resolve => t.step_timeout(resolve, 1000));

	await agent.navigate(landingUrl);
	assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

	// We should have to wait for this response. While timing is going to be
	// somewhat variable here, it's probably wrong for the response to seem
	// to take less than 1 second (since we only waited for 1 second).
	// Regardless, these events should be normally ordered.
	const [entry] = await agent.execute_script(
	() => performance.getEntriesByType('navigation'));
	assert_less_than_equal(entry.connectEnd, entry.requestStart);
	assert_less_than_equal(entry.requestStart + 1000, entry.responseStart);
	assert_greater_than(entry.responseStart, 1000);
	}, "PerformanceNavigationTiming data should show noticeable TTFB if the response is slow");

	subsetTestByKey('waitingForRedirect', promise_test, async t => {
	const agent = await spawnWindow(t);
	const landingUrl = agent.getExecutorURL({page: 2});
	const slowRedirectUrl = new URL(`/common/slow-redirect.py?delay=4&location=${encodeURIComponent(landingUrl)}`, document.baseURI);
	await agent.forceSinglePrefetch(slowRedirectUrl, {}, /wait_for_completion=/false);
	await new Promise(resolve => t.step_timeout(resolve, 1000));

	await agent.navigate(slowRedirectUrl, {expectedDestinationUrl: landingUrl});
	assert_prefetched(await agent.getRequestHeaders(), `${landingUrl} should have been prefetched.`);

	// We should have to wait for this response. While timing is going to be
	// somewhat variable here, it's probably wrong for the response to seem
	// to take less than 1 second (since we only waited for 1 second).
	// Regardless, these events should be normally ordered.
	const [entry] = await agent.execute_script(
	() => performance.getEntriesByType('navigation'));
	assert_less_than_equal(entry.connectEnd, entry.requestStart);
	assert_less_than_equal(entry.requestStart, entry.responseStart);
	assert_greater_than(entry.responseStart, 1000);
	}, "PerformanceNavigationTiming data should show noticeable TTFB if the response is slow");
	</script>