Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test has a WPT meta file that expects 2 subtest issues.
- This WPT test may be referenced by the following Test IDs:
- /fetch/compression-dictionary/dictionary-match.tentative.https.html - WPT Dashboard Interop Dashboard
<!DOCTYPE html>
<head>
<meta charset="utf-8">
<meta name="timeout" content="long"/>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/get-host-info.sub.js"></script>
<script src="/common/utils.js"></script>
<script src="./resources/compression-dictionary-util.sub.js"></script>
</head>
<body>
<script>
compression_dictionary_promise_test(async (t) => {
const match_dest = encodeURIComponent('("asdf")');
const pattern = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers.py');
await fetch(
`${kRegisterDictionaryPath}?id=id1&match-dest=${match_dest}&match=${pattern}`);
await registerAltDictionaryAndWait(t);
const headers = await (await fetch('./resources/echo-headers.py')).json();
assert_false("available-dictionary" in headers);
}, 'Dictionary with unknown match-dest is not used for fetch() API');
compression_dictionary_promise_test(async (t) => {
const match_dest = encodeURIComponent('()');
const dict = await (await fetch(`${kRegisterDictionaryPath}?id=test&match-dest=${match_dest}`)).text();
assert_equals(
await waitUntilAvailableDictionaryHeader(t, {}),
kDefaultDictionaryHashBase64);
assert_equals(await checkHeader('dictionary-id', {}), '"test"');
}, 'Dictionary registration with empty match-dest list acts as wildcard');
compression_dictionary_promise_test(async (t) => {
const match_dest = encodeURIComponent('("")');
const dict = await (await fetch(`${kRegisterDictionaryPath}?id=test&match-dest=${match_dest}`)).text();
assert_equals(
await waitUntilAvailableDictionaryHeader(t, {}),
kDefaultDictionaryHashBase64);
assert_equals(await checkHeader('dictionary-id', {}), '"test"');
}, 'Dictionary registration with matching fetch destination');
compression_dictionary_promise_test(async (t) => {
const match_dest = encodeURIComponent('("script")');
const pattern = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers.py');
await fetch(
`${kRegisterDictionaryPath}?id=id1&match-dest=${match_dest}&match=${pattern}`);
await registerAltDictionaryAndWait(t);
const headers = await (await fetch('./resources/echo-headers.py')).json();
assert_false("available-dictionary" in headers);
}, 'Dictionary with non-matching match-dest is not used');
compression_dictionary_promise_test(async (t) => {
const match_dest = encodeURIComponent('("asdf" "")');
const dict = await (await fetch(`${kRegisterDictionaryPath}?id=test&match-dest=${match_dest}`)).text();
assert_equals(
await waitUntilAvailableDictionaryHeader(t, {}),
kDefaultDictionaryHashBase64);
assert_equals(await checkHeader('dictionary-id', {}), '"test"');
}, 'Dictionary registration with unknown match-dest and empty string matches fetch destination');
compression_dictionary_promise_test(async (t) => {
const match_specific = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers.py');
const match_medium = encodeURIComponent(
'/fetch/compression-dictionary/resources/*');
const match_general = encodeURIComponent(
'/fetch/compression-dictionary/*');
const dictionary_path_specific =
`${kRegisterDictionaryPath}?id=specific&content=specific&` +
`match=${match_specific}`;
const dictionary_path_medium =
`${kRegisterDictionaryPath}?id=medium&content=medium&` +
`match=${match_medium}`;
const dictionary_path_general =
`${kRegisterDictionaryPath}?id=general&content=general&` +
`match=${match_general}`;
const expected_specific_hash = await calculateDictionaryHash('specific');
const expected_medium_hash = await calculateDictionaryHash('medium');
await fetch(dictionary_path_specific);
await fetch(dictionary_path_medium);
await fetch(dictionary_path_general);
// echo-headers.py matches all 3, specific (length 55) is the most specific.
const hash_specific = await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_specific_hash
});
assert_equals(hash_specific, expected_specific_hash);
// echo-headers2.py matches medium (length 41) and general (length 31),
// medium is more specific.
const hash_medium = await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_medium_hash,
use_alt_path: true
});
assert_equals(hash_medium, expected_medium_hash);
}, 'Best match algorithm prioritizes dictionaries with longer match patterns');
compression_dictionary_promise_test(async (t) => {
const match_longer_nodest = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers*.py');
const match_medium_dest = encodeURIComponent(
'/fetch/compression-dictionary/*/echo-headers2.py');
const match_shorter_dest = encodeURIComponent(
'/fetch/compression-dictionary/*');
const match_dest = encodeURIComponent('("")');
const dictionary_path_longer_nodest =
`${kRegisterDictionaryPath}?id=longer-nodest&content=longer-nodest&` +
`match=${match_longer_nodest}`;
const dictionary_path_medium_dest =
`${kRegisterDictionaryPath}?id=medium-dest&content=medium-dest&` +
`match-dest=${match_dest}&match=${match_medium_dest}`;
const dictionary_path_shorter_dest =
`${kRegisterDictionaryPath}?id=shorter-dest&content=shorter-dest&` +
`match-dest=${match_dest}&match=${match_shorter_dest}`;
const expected_longer_hash = await calculateDictionaryHash('longer-nodest');
const expected_medium_hash = await calculateDictionaryHash('medium-dest');
const expected_shorter_hash = await calculateDictionaryHash('shorter-dest');
await fetch(dictionary_path_longer_nodest);
await fetch(dictionary_path_medium_dest);
await fetch(dictionary_path_shorter_dest);
// echo-headers.py matches longer-nodest (no dest) and shorter-dest (with dest).
// shorter-dest wins because it has match-dest.
const hash_selected = await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_shorter_hash
});
assert_equals(hash_selected, expected_shorter_hash);
// echo-headers2.py matches all three. medium-dest and shorter-dest have dest.
// medium-dest wins because it has a longer match pattern.
const hash_medium = await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_medium_hash,
use_alt_path: true
});
assert_equals(hash_medium, expected_medium_hash);
}, 'match-dest presence takes priority over longer match patterns');
compression_dictionary_promise_test(async (t) => {
const match_specific_1 = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers*.py');
const match_specific_2 = encodeURIComponent(
'/fetch/compression-dictionary/resources/echo-headers.py*');
const dictionary_path_first =
`${kRegisterDictionaryPath}?id=first-fetched&content=first-fetched-content&` +
`match=${match_specific_1}`;
const dictionary_path_second =
`${kRegisterDictionaryPath}?id=second-fetched&content=second-fetched-content&` +
`match=${match_specific_2}`;
const expected_first_hash = await calculateDictionaryHash('first-fetched-content');
const expected_second_hash = await calculateDictionaryHash('second-fetched-content');
await (await fetch(dictionary_path_first)).text();
assert_equals(
await waitUntilAvailableDictionaryHeader(t, {}), expected_first_hash);
// Wait a short delay to ensure different fetch times.
await new Promise(resolve => t.step_timeout(resolve, 50));
await (await fetch(dictionary_path_second)).text();
// We must wait until second-fetched is registered.
const hash_selected = await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_second_hash
});
assert_equals(hash_selected, expected_second_hash);
// The first dictionary should still be available for paths that only match it.
assert_equals(
await waitUntilAvailableDictionaryHeader(t, {
expected_header: expected_first_hash,
use_alt_path: true
}),
expected_first_hash);
}, 'Most recently fetched dictionary takes priority when match lengths are equal');
</script>
</body>