Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #18676 - gterzian:continue_http_cache_work, r=jdm

Browse source 
Continue http cache work

<!-- Please describe your changes on the following line: -->

Work in progress, and not quite worth a review yet. (Continuation of https://github.com/servo/servo/pull/4117)

TODO

- [ ] cache metadata (find some subset of`net_traits::Metadata` that can be shared across threads, it seems the problem is mainly stuff inside `hyper::header` in the `headers` field)

- [ ] determine which other fields of a `Response` need to be cached, so a full and valid one can be returned upon a cache hit.

- [ ] determine how to best share the cache across fetch threads (inside HttpState like I tried now?)

- [ ] Spend more time reading the spec and make sure the cache follows it where it matters.

- [ ] Make the current wpt tests pass.

- [ ] More...

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [ ] `./mach build -d` does not report any errors
- [ ] `./mach test-tidy` does not report any errors
- [ ] These changes fix #12972  (github issue number if applicable).

<!-- Either: -->
- [ ] There are tests for these changes OR
- [ ] These changes do not require tests because _____

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/18676)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2017-11-20 18:22:06 -06:00 • committed by GitHub
commit e2bc0f017c
37 changed files with 1238 additions and 631 deletions
Download patch file Download diff file Expand all files Collapse all files

8
tests/wpt/metadata/MANIFEST.json
View file

@ -528584,7 +528584,7 @@
"support"
],
"fetch/http-cache/cc-request.html": [
"d4417b8fd444362a3f217d1c95d37811a608e1a7",
"2002d341679139428e164cfe916dd39b9b664a3e",
"testharness"
],
"fetch/http-cache/freshness.html": [
@ -528592,7 +528592,7 @@
"testharness"
],
"fetch/http-cache/heuristic.html": [
"5b0d55f891cb2e235456cd65f4e9f63e07999410",
"63837026eb6085fc7d6220c3dcab200b4bcd1eca",
"testharness"
],
"fetch/http-cache/http-cache.js": [
@ -528604,7 +528604,7 @@
"testharness"
],
"fetch/http-cache/partial.html": [
"243e57c39f9e45e3e2acf845b36f3a140e3763bc",
"685057fe8876321a5d42bcf1e7582e6f0b745f85",
"testharness"
],
"fetch/http-cache/resources/http-cache.py": [
@ -528616,7 +528616,7 @@
"testharness"
],
"fetch/http-cache/vary.html": [
"fa9a2e0554671bf2de5826e66ac0ea73de28d530",
"45f337270cfa90932c7469802655e313367ac92f",
"testharness"
],
"fetch/nosniff/image.html": [

14
tests/wpt/metadata/cors/304.htm.ini
View file

@ -1,14 +0,0 @@
[304.htm]
type: testharness
[A 304 response with no CORS headers inherits from the stored response]
expected: FAIL
[A 304 can expand Access-Control-Expose-Headers]
expected: FAIL
[A 304 can contract Access-Control-Expose-Headers]
expected: FAIL
[A 304 can change Access-Control-Allow-Origin]
expected: FAIL

17
tests/wpt/metadata/fetch/api/basic/accept-header.any.js.ini
View file

@ -1,17 +0,0 @@
[accept-header.any.html]
type: testharness
[Request through fetch should have 'accept' header with value 'custom/*']
expected: FAIL
[Request through fetch should have 'accept-language' header with value 'bzh']
expected: FAIL
[accept-header.any.worker.html]
type: testharness
[Request through fetch should have 'accept' header with value 'custom/*']
expected: FAIL
[Request through fetch should have 'accept-language' header with value 'bzh']
expected: FAIL

6
tests/wpt/metadata/fetch/api/basic/request-headers.any.js.ini
View file

@ -39,12 +39,6 @@
[Fetch with Chicken with body]
expected: FAIL
[Fetch with TacO and mode "same-origin" needs an Origin header]
expected: FAIL
[Fetch with TacO and mode "cors" needs an Origin header]
expected: FAIL
[request-headers.any.worker.html]
type: testharness

9
tests/wpt/metadata/fetch/api/cors/cors-preflight-star.any.js.ini
View file

@ -1,17 +1,8 @@
[cors-preflight-star.any.html]
type: testharness
[CORS that succeeds with credentials: false; method: SUPER (allowed: *); header: X-Test,1 (allowed: x-test)]
expected: FAIL
[CORS that succeeds with credentials: false; method: OK (allowed: *); header: X-Test,1 (allowed: *)]
expected: FAIL
[CORS that fails with credentials: true; method: GET (allowed: get); header: X-Test,1 (allowed: *)]
expected: FAIL
[CORS that fails with credentials: true; method: GET (allowed: *); header: X-Test,1 (allowed: *)]
expected: FAIL
[CORS that succeeds with credentials: true; method: PUT (allowed: PUT); header: (allowed: *)]
expected: FAIL

30
tests/wpt/metadata/fetch/api/cors/cors-preflight.any.js.ini
View file

@ -1,47 +1,17 @@
[cors-preflight.any.html]
type: testharness
[CORS [PATCH\], server allows]
expected: FAIL
[CORS [NEW\], server allows]
expected: FAIL
[CORS [GET\] [x-test-header: allowed\], server allows]
expected: FAIL
[CORS [GET\] [x-test-header: refused\], server refuses]
expected: FAIL
[CORS [GET\] [several headers\], server allows]
expected: FAIL
[CORS [GET\] [several headers\], server refuses]
expected: FAIL
[CORS [PUT\] [several headers\], server allows]
expected: FAIL
[cors-preflight.any.worker.html]
type: testharness
[CORS [PATCH\], server allows]
expected: FAIL
[CORS [NEW\], server allows]
expected: FAIL
[CORS [GET\] [x-test-header: allowed\], server allows]
expected: FAIL
[CORS [GET\] [x-test-header: refused\], server refuses]
expected: FAIL
[CORS [GET\] [several headers\], server allows]
expected: FAIL
[CORS [GET\] [several headers\], server refuses]
expected: FAIL
[CORS [PUT\] [several headers\], server allows]
expected: FAIL

185
tests/wpt/metadata/fetch/api/cors/cors-redirect-preflight.any.js.ini
View file

@ -1,185 +0,0 @@
[cors-redirect-preflight.any.html]
type: testharness
[Redirect 301: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 301: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 301: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 301: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 301: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 301: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 302: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 302: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 302: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 303: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 303: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 303: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 307: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 307: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 307: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 308: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 308: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 308: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[cors-redirect-preflight.any.worker.html]
type: testharness
[Redirect 301: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 301: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 301: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 301: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 301: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 301: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 302: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 302: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 302: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 302: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 303: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 303: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 303: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 303: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 307: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 307: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 307: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 307: cors to another cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: same origin to cors (preflight after redirection success case)]
expected: FAIL
[Redirect 308: same origin to cors (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: cors to same origin (preflight after redirection success case)]
expected: FAIL
[Redirect 308: cors to same origin (preflight after redirection failure case)]
expected: FAIL
[Redirect 308: cors to another cors (preflight after redirection success case)]
expected: FAIL
[Redirect 308: cors to another cors (preflight after redirection failure case)]
expected: FAIL

23
tests/wpt/metadata/fetch/api/credentials/authentication-basic.any.js.ini
View file

@ -1,23 +0,0 @@
[authentication-basic.any.html]
type: testharness
[User-added Authorization header with include mode]
expected: FAIL
[User-added Authorization header with same-origin mode]
expected: FAIL
[User-added Authorization header with omit mode]
expected: FAIL
[authentication-basic.any.worker.html]
type: testharness
[User-added Authorization header with include mode]
expected: FAIL
[User-added Authorization header with same-origin mode]
expected: FAIL
[User-added Authorization header with omit mode]
expected: FAIL

3
tests/wpt/metadata/fetch/api/request/request-cache-default-conditional.html.ini
View file

@ -1,3 +0,0 @@
[request-cache-default-conditional.html]
type: testharness
disabled: https://github.com/servo/servo/issues/13441

11
tests/wpt/metadata/fetch/api/request/request-cache-default.html.ini
View file

@ -1,11 +0,0 @@
[request-cache-default.html]
type: testharness
[RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with Etag and fresh response]
expected: FAIL
[RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with date and fresh response]
expected: FAIL
[RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with Last-Modified and fresh response]
expected: FAIL

29
tests/wpt/metadata/fetch/api/request/request-cache-force-cache.html.ini
View file

@ -1,29 +0,0 @@
[request-cache-force-cache.html]
type: testharness
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Etag and stale response]
expected: FAIL
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with date and stale response]
expected: FAIL
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with Etag and fresh response]
expected: FAIL
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with date and fresh response]
expected: FAIL
[RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and fresh response]
expected: FAIL
[RequestCache "force-cache" stores the response in the cache if it goes to the network with date and fresh response]
expected: FAIL
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Last-Modified and stale response]
expected: FAIL
[RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with Last-Modified and fresh response]
expected: FAIL
[RequestCache "force-cache" stores the response in the cache if it goes to the network with Last-Modified and fresh response]
expected: FAIL

65
tests/wpt/metadata/fetch/api/request/request-cache-only-if-cached.html.ini
View file

@ -1,65 +0,0 @@
[request-cache-only-if-cached.html]
type: testharness
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with Etag and fresh response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with date and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and stale response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and stale response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and stale response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Last-Modified and stale response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Last-Modified and fresh response]
expected: FAIL
[RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with Last-Modified and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Last-Modified and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Last-Modified and stale response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Last-Modified and fresh response]
expected: FAIL
[RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Last-Modified and stale response]
expected: FAIL

20
tests/wpt/metadata/fetch/api/request/request-cache-reload.html.ini
View file

@ -1,20 +0,0 @@
[request-cache-reload.html]
type: testharness
[RequestCache "reload" mode does store the response in the cache with Etag and fresh response]
expected: FAIL
[RequestCache "reload" mode does store the response in the cache with date and fresh response]
expected: FAIL
[RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response]
expected: FAIL
[RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response]
expected: FAIL
[RequestCache "reload" mode does store the response in the cache with Last-Modified and fresh response]
expected: FAIL
[RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Last-Modified and fresh response]
expected: FAIL

14
tests/wpt/metadata/fetch/http-cache/304-update.html.ini
View file

@ -1,14 +0,0 @@
[304-update.html]
type: testharness
[HTTP cache updates returned headers from a Last-Modified 304.]
expected: FAIL
[HTTP cache updates stored headers from a Last-Modified 304.]
expected: FAIL
[HTTP cache updates returned headers from a ETag 304.]
expected: FAIL
[HTTP cache updates stored headers from a ETag 304.]
expected: FAIL

6
tests/wpt/metadata/fetch/http-cache/cc-request.html.ini
View file

@ -1,11 +1,5 @@
[cc-request.html]
type: testharness
[HTTP cache does use aged stale response when request contains Cache-Control: max-stale that permits its use.]
expected: FAIL
[HTTP cache does reuse stale response with Age header when request contains Cache-Control: max-stale that permits its use.]
expected: FAIL
[HTTP cache generates 504 status code when nothing is in cache and request contains Cache-Control: only-if-cached.]
expected: FAIL

20
tests/wpt/metadata/fetch/http-cache/freshness.html.ini
View file

@ -1,20 +0,0 @@
[freshness.html]
type: testharness
[HTTP cache reuses a response with a future Expires.]
expected: FAIL
[HTTP cache reuses a response with positive Cache-Control: max-age.]
expected: FAIL
[HTTP cache reuses a response with positive Cache-Control: max-age and a past Expires.]
expected: FAIL
[HTTP cache reuses a response with positive Cache-Control: max-age and an invalid Expires.]
expected: FAIL
[HTTP cache stores a response with Cache-Control: no-cache, but revalidates upon use.]
expected: FAIL
[HTTP cache stores a response with Cache-Control: no-cache, but revalidates upon use, even with max-age and Expires.]
expected: FAIL

29
tests/wpt/metadata/fetch/http-cache/heuristic.html.ini
View file

@ -1,29 +0,0 @@
[heuristic.html]
type: testharness
[HTTP cache reuses an unknown response with Last-Modified based upon heuristic freshness when Cache-Control: public is present.]
expected: FAIL
[HTTP cache reuses a 200 OK response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 203 Non-Authoritative Information response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 204 No Content response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 404 Not Found response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 405 Method Not Allowed response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 410 Gone response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 414 URI Too Long response with Last-Modified based upon heuristic freshness.]
expected: FAIL
[HTTP cache reuses a 501 Not Implemented response with Last-Modified based upon heuristic freshness.]
expected: FAIL

20
tests/wpt/metadata/fetch/http-cache/invalidate.html.ini
View file

@ -1,20 +0,0 @@
[invalidate.html]
type: testharness
[HTTP cache does not invalidate after a failed response from an unsafe request]
expected: FAIL
[HTTP cache invalidates after a successful response from an unknown method]
expected: FAIL
[HTTP cache does not invalidate Location URL after a failed response from an unsafe request]
expected: FAIL
[HTTP cache invalidates Location URL after a successful response from an unknown method]
expected: FAIL
[HTTP cache does not invalidate Content-Location URL after a failed response from an unsafe request]
expected: FAIL
[HTTP cache invalidates Content-Location URL after a successful response from an unknown method]
expected: FAIL

8
tests/wpt/metadata/fetch/http-cache/partial.html.ini
View file

@ -1,13 +1,5 @@
[partial.html]
type: testharness
[HTTP cache stores partial content and reuses it.]
expected: FAIL
[HTTP cache stores complete response and serves smaller ranges from it.]
expected: FAIL
[HTTP cache stores partial response and serves smaller ranges from it.]
expected: FAIL
[HTTP cache stores partial content and completes it.]
expected: FAIL

41
tests/wpt/metadata/fetch/http-cache/status.html.ini
View file

@ -1,41 +0,0 @@
[status.html]
type: testharness
[HTTP cache avoids going to the network if it has a fresh 200 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 203 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 204 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 299 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 400 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 404 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 410 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 499 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 500 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 502 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 503 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 504 response.]
expected: FAIL
[HTTP cache avoids going to the network if it has a fresh 599 response.]
expected: FAIL

17
tests/wpt/metadata/fetch/http-cache/vary.html.ini
View file

@ -1,17 +0,0 @@
[vary.html]
type: testharness
[HTTP cache reuses Vary response when request matches.]
expected: FAIL
[HTTP cache doesn't invalidate existing Vary response.]
expected: FAIL
[HTTP cache doesn't pay attention to headers not listed in Vary.]
expected: FAIL
[HTTP cache reuses two-way Vary response when request matches.]
expected: FAIL
[HTTP cache reuses three-way Vary response when request matches.]
expected: FAIL

19
tests/wpt/mozilla/meta/MANIFEST.json
View file

@ -12466,6 +12466,11 @@
{}
]
],
"mozilla/resources/http-cache.js": [
[
{}
]
],
"mozilla/resources/iframe_contentDocument_inner.html": [
[
{}
@ -33218,6 +33223,12 @@
{}
]
],
"mozilla/http-cache.html": [
[
"/_mozilla/mozilla/http-cache.html",
{}
]
],
"mozilla/iframe-unblock-onload.html": [
[
"/_mozilla/mozilla/iframe-unblock-onload.html",
@ -66309,6 +66320,10 @@
"592f69ee432ba5bc7a2f2649e72e083d21393496",
"testharness"
],
"mozilla/http-cache.html": [
"33827dc9bdb0efcbcae4f730086693be315cfc14",
"testharness"
],
"mozilla/iframe-unblock-onload.html": [
"8734756947d36b047df256f27adc56fce7e31f88",
"testharness"
@ -71981,6 +71996,10 @@
"78686147f85e4146e7fc58c1f67a613f65b099a2",
"support"
],
"mozilla/resources/http-cache.js": [
"c6b1ee9def26d4e12a1b93e551c225f82b4717c2",
"support"
],
"mozilla/resources/iframe_contentDocument_inner.html": [
"eb1b1ae3bb7a437fc4fbdd1f537881890fe6347c",
"support"

3
tests/wpt/mozilla/meta/mozilla/http-cache.html.ini Normal file
View file

@ -0,0 +1,3 @@
[http-cache.html]
type: testharness
prefs: [network.http-cache.disabled:true]

50
tests/wpt/mozilla/tests/mozilla/http-cache.html Normal file
View file

@ -0,0 +1,50 @@
<html>
<head>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/utils.js"></script>
<script src="resources/http-cache.js"></script>
<script src="/fetch/http-cache/resources/http-cache.py"></script>
<script>
var tests = [];
function check_status(status) {
var code = status[0];
var phrase = status[1];
var body = status[2];
if (body === undefined) {
body = http_content(code);
}
tests.push({
name: 'HTTP cache, when disabled, does not cache a ' + code + ' response.',
requests: [
{
template: "fresh",
response_status: [code, phrase],
response_body: body
}, {
expected_type: "not_cached",
response_status: [code, phrase],
response_body: body
}
]
})
}
[
[200, 'OK'],
[203, "Non-Authoritative Information"],
[204, "No Content", ""],
[299, "Whatever"],
[400, "Bad Request"],
[404, "Not Found"],
[410, "Gone"],
[499, "Whatever"],
[500, "Internal Server Error"],
[502, "Bad Gateway"],
[503, "Service Unavailable"],
[504, "Gateway Timeout"],
[599, "Whatever"]
].forEach(check_status);
run_tests(tests);
</script>
</head>
</html>

286
tests/wpt/mozilla/tests/mozilla/resources/http-cache.js Normal file
View file

@ -0,0 +1,286 @@
/**
* Each test run gets its own URL and randomized content and operates independently.
*
* Tests are an array of objects, each representing a request to make and check.
* The cache.py server script stashes an entry containing observed headers for
* each request it receives. When the test fetches have run, this state is retrieved
* and the expected_* lists are checked, including their length.
*
* Request object keys:
* - template - A template object for the request, by name -- see "templates" below.
* - request_method - A string containing the HTTP method to be used.
* - request_headers - An array of [header_name_string, header_value_string] arrays to
* emit in the request.
* - request_body - A string to use as the request body.
* - mode - The mode string to pass to fetch().
* - credentials - The credentials string to pass to fetch().
* - cache - The cache string to pass to fetch().
* - pause_after - Boolean controlling a 3-second pause after the request completes.
* - response_status - A [number, string] array containing the HTTP status code
* and phrase to return.
* - response_headers - An array of [header_name_string, header_value_string] arrays to
* emit in the response. These values will also be checked like
* expected_response_headers, unless there is a third value that is
* false.
* - response_body - String to send as the response body. If not set, it will contain
* the test identifier.
* - expected_type - One of ["cached", "not_cached", "lm_validate", "etag_validate", "error"]
* - expected_status - A number representing a HTTP status code to check the response for.
* If not set, the value of response_status[0] will be used; if that
* is not set, 200 will be used.
* - expected_request_headers - An array of [header_name_string, header_value_string] representing
* headers to check the request for.
* - expected_response_headers - An array of [header_name_string, header_value_string] representing
* headers to check the response for. See also response_headers.
* - expected_response_text - A string to check the response body against.
*/
function make_url(uuid, requests, idx) {
var arg = "";
if ("query_arg" in requests[idx]) {
arg = "&target=" + requests[idx].query_arg;
}
return "/fetch/http-cache/resources/http-cache.py?token=" + uuid + "&info=" + btoa(JSON.stringify(requests)) + arg;
}
function server_state(uuid) {
return fetch("/fetch/http-cache/resources/http-cache.py?querystate&token=" + uuid)
.then(function(response) {
return response.text();
}).then(function(text) {
// null will be returned if the server never received any requests
// for the given uuid. Normalize that to an empty list consistent
// with our representation.
return JSON.parse(text) || [];
});
}
templates = {
"fresh": {
"response_headers": [
['Expires', http_date(100000)],
['Last-Modified', http_date(0)]
]
},
"stale": {
"response_headers": [
['Expires', http_date(-5000)],
['Last-Modified', http_date(-100000)]
]
},
"lcl_response": {
"response_headers": [
['Location', "location_target"],
['Content-Location', "content_location_target"]
]
},
"location": {
"query_arg": "location_target",
"response_headers": [
['Expires', http_date(100000)],
['Last-Modified', http_date(0)]
]
},
"content_location": {
"query_arg": "content_location_target",
"response_headers": [
['Expires', http_date(100000)],
['Last-Modified', http_date(0)]
]
}
}
function make_test(raw_requests) {
var requests = [];
for (var i = 0; i < raw_requests.length; i++) {
var request = raw_requests[i];
if ("template" in request) {
var template = templates[request["template"]];
for (var member in template) {
if (! request.hasOwnProperty(member)) {
request[member] = template[member];
}
}
}
if ("expected_type" in request && request.expected_type === "cached") {
// requests after one that's expected to be cached will get out of sync
// with the server; not currently supported.
if (raw_requests.length > i + 1) {
assert_unreached("Making requests after something is expected to be cached.");
}
}
requests.push(request);
}
return function(test) {
var uuid = token();
var fetch_functions = [];
for (var i = 0; i < requests.length; ++i) {
fetch_functions.push({
code: function(idx) {
var init = {};
var url = make_url(uuid, requests, idx);
var config = requests[idx];
if ("request_method" in config) {
init.method = config["request_method"];
}
if ("request_headers" in config) {
init.headers = config["request_headers"];
}
if ("request_body" in config) {
init.body = config["request_body"];
}
if ("mode" in config) {
init.mode = config["mode"];
}
if ("credentials" in config) {
init.mode = config["credentials"];
}
if ("cache" in config) {
init.cache = config["cache"];
}
console.log(url, init)
return fetch(url, init.cache)
.then(function(response) {
var res_num = parseInt(response.headers.get("Server-Request-Count"));
var req_num = idx + 1;
if ("expected_type" in config) {
if (config.expected_type === "error") {
assert_true(false, "Request " + req_num + " should have been an error");
return [response.text(), response_status];
}
if (config.expected_type === "cached") {
assert_less_than(res_num, req_num, "Response used");
}
if (config.expected_type === "not_cached") {
assert_equals(res_num, req_num, "Response used");
}
}
if ("expected_status" in config) {
assert_equals(response.status, config.expected_status, "Response status");
} else if ("response_status" in config) {
assert_equals(response.status, config.response_status[0], "Response status");
} else {
assert_equals(response.status, 200, "Response status")
}
if ("response_headers" in config) {
config.response_headers.forEach(function(header) {
if (header.len < 3 || header[2] === true) {
assert_equals(response.headers.get(header[0]), header[1], "Response header")
}
})
}
if ("expected_response_headers" in config) {
config.expected_response_headers.forEach(function(header) {
assert_equals(response.headers.get(header[0]), header[1], "Response header");
});
}
return response.text();
}).then(function(res_body) {
if ("expected_response_text" in config) {
assert_equals(res_body, config.expected_response_text, "Response body");
} else if ("response_body" in config) {
assert_equals(res_body, config.response_body, "Response body");
} else {
assert_equals(res_body, uuid, "Response body");
}
}, function(reason) {
if ("expected_type" in config && config.expected_type === "error") {
assert_throws(new TypeError(), function() { throw reason; });
} else {
throw reason;
}
});
},
pause_after: "pause_after" in requests[i] && true || false
});
}
function pause() {
return new Promise(function(resolve, reject) {
step_timeout(function() {
return resolve()
}, 3000);
});
}
// TODO: it would be nice if this weren't serialised.
var idx = 0;
function run_next_step() {
if (fetch_functions.length) {
var fetch_function = fetch_functions.shift();
if (fetch_function.pause_after > 0) {
return fetch_function.code(idx++)
.then(pause)
.then(run_next_step);
} else {
return fetch_function.code(idx++)
.then(run_next_step);
}
} else {
return Promise.resolve();
}
}
return run_next_step()
.then(function() {
// Now, query the server state
return server_state(uuid);
}).then(function(state) {
for (var i = 0; i < requests.length; ++i) {
var expected_validating_headers = []
var req_num = i + 1;
if ("expected_type" in requests[i]) {
if (requests[i].expected_type === "cached") {
assert_true(state.length <= i, "cached response used for request " + req_num);
continue; // the server will not see the request, so we can't check anything else.
}
if (requests[i].expected_type === "not_cached") {
assert_false(state.length <= i, "cached response used for request " + req_num);
}
if (requests[i].expected_type === "etag_validated") {
expected_validating_headers.push('if-none-match')
}
if (requests[i].expected_type === "lm_validated") {
expected_validating_headers.push('if-modified-since')
}
}
for (var j in expected_validating_headers) {
var vhdr = expected_validating_headers[j];
assert_own_property(state[i].request_headers, vhdr, " has " + vhdr + " request header");
}
if ("expected_request_headers" in requests[i]) {
var expected_request_headers = requests[i].expected_request_headers;
for (var j = 0; j < expected_request_headers.length; ++j) {
var expected_header = expected_request_headers[j];
assert_equals(state[i].request_headers[expected_header[0].toLowerCase()],
expected_header[1]);
}
}
}
});
};
}
function run_tests(tests)
{
tests.forEach(function(info) {
promise_test(make_test(info.requests), info.name);
});
}
function http_date(delta) {
return new Date(Date.now() + (delta * 1000)).toGMTString();
}
var content_store = {};
function http_content(cs_key) {
if (cs_key in content_store) {
return content_store[cs_key];
} else {
var content = btoa(Math.random() * Date.now());
content_store[cs_key] = content;
return content;
}
}

3
tests/wpt/web-platform-tests/fetch/http-cache/cc-request.html
View file

@ -201,7 +201,8 @@
request_headers: [
["Cache-Control", "only-if-cached"]
],
expected_status: 504
expected_status: 504,
expected_response_text: ""
}
]
}

4
tests/wpt/web-platform-tests/fetch/http-cache/heuristic.html
View file

@ -26,6 +26,7 @@
},
{
expected_type: "cached",
response_status: [299, "Whatever"],
}
]
},
@ -35,8 +36,7 @@
{
response_status: [299, "Whatever"],
response_headers: [
['Last-Modified', http_date(-3 * 100)],
['Cache-Control', 'public']
['Last-Modified', http_date(-3 * 100)]
],
},
{

103
tests/wpt/web-platform-tests/fetch/http-cache/partial.html
View file

@ -24,7 +24,7 @@
response_status: [206, "Partial Content"],
response_headers: [
['Cache-Control', 'max-age=3600'],
['Content-Range', 'bytes 0-4/10']
['Content-Range', 'bytes 4-9/10']
],
response_body: "01234",
expected_request_headers: [
@ -36,12 +36,13 @@
['Range', "bytes=-5"]
],
expected_type: "cached",
expected_status: 206
expected_status: 206,
expected_response_text: "01234"
}
]
},
{
name: 'HTTP cache stores complete response and serves smaller ranges from it.',
name: 'HTTP cache stores complete response and serves smaller ranges from it(byte-range-spec).',
requests: [
{
response_headers: [
@ -51,15 +52,54 @@
},
{
request_headers: [
['Range', "bytes=-1"]
['Range', "bytes=0-1"]
],
expected_type: "cached",
expected_status: 206,
expected_response_text: "01"
},
]
},
{
name: 'HTTP cache stores complete response and serves smaller ranges from it(absent last-byte-pos).',
requests: [
{
response_headers: [
['Cache-Control', 'max-age=3600'],
],
response_body: "01234567890",
},
{
request_headers: [
['Range', "bytes=1-"]
],
expected_type: "cached",
expected_status: 206,
expected_response_text: "1234567890"
}
]
},
{
name: 'HTTP cache stores partial response and serves smaller ranges from it.',
name: 'HTTP cache stores complete response and serves smaller ranges from it(suffix-byte-range-spec).',
requests: [
{
response_headers: [
['Cache-Control', 'max-age=3600'],
],
response_body: "0123456789A",
},
{
request_headers: [
['Range', "bytes=-1"]
],
expected_type: "cached",
expected_status: 206,
expected_response_text: "A"
}
]
},
{
name: 'HTTP cache stores partial response and serves smaller ranges from it(byte-range-spec).',
requests: [
{
request_headers: [
@ -68,7 +108,55 @@
response_status: [206, "Partial Content"],
response_headers: [
['Cache-Control', 'max-age=3600'],
['Content-Range', 'bytes 0-4/10']
['Content-Range', 'bytes 4-9/10']
],
response_body: "01234",
},
{
request_headers: [
['Range', "bytes=6-8"]
],
expected_type: "cached",
expected_status: 206,
expected_response_text: "234"
}
]
},
{
name: 'HTTP cache stores partial response and serves smaller ranges from it(absent last-byte-pos).',
requests: [
{
request_headers: [
['Range', "bytes=-5"]
],
response_status: [206, "Partial Content"],
response_headers: [
['Cache-Control', 'max-age=3600'],
['Content-Range', 'bytes 4-9/10']
],
response_body: "01234",
},
{
request_headers: [
['Range', "bytes=6-"]
],
expected_type: "cached",
expected_status: 206,
expected_response_text: "234"
}
]
},
{
name: 'HTTP cache stores partial response and serves smaller ranges from it(suffix-byte-range-spec).',
requests: [
{
request_headers: [
['Range', "bytes=-5"]
],
response_status: [206, "Partial Content"],
response_headers: [
['Cache-Control', 'max-age=3600'],
['Content-Range', 'bytes 4-9/10']
],
response_body: "01234",
},
@ -77,7 +165,8 @@
['Range', "bytes=-1"]
],
expected_type: "cached",
expected_response_text: "01"
expected_status: 206,
expected_response_text: "4"
}
]
},

55
tests/wpt/web-platform-tests/fetch/http-cache/vary.html
View file

@ -103,6 +103,7 @@
request_headers: [
["Foo", "1"]
],
response_body: http_content('foo_1'),
expected_type: "cached"
}
]
@ -245,7 +246,32 @@
]
},
{
name: "HTTP cache doesn't use three-way Vary response when request omits variant header.",
name: "HTTP cache doesn't use three-way Vary response when request doesn't match, regardless of header order.",
requests: [
{
request_headers: [
["Foo", "1"],
["Bar", "abc4"],
["Baz", "789"]
],
response_headers: [
["Expires", http_date(5000)],
["Last-Modified", http_date(-3000)],
["Vary", "Foo, Bar, Baz"]
]
},
{
request_headers: [
["Foo", "1"],
["Bar", "abc"],
["Baz", "789"]
],
expected_type: "not_cached"
}
]
},
{
name: "HTTP cache uses three-way Vary response when both request and the original request omited a variant header.",
requests: [
{
request_headers: [
@ -259,6 +285,33 @@
]
},
{
request_headers: [
["Foo", "1"],
["Baz", "789"]
],
expected_type: "cached"
}
]
},
{
name: "HTTP cache doesn't use Vary response with a field value of '*'.",
requests: [
{
request_headers: [
["Foo", "1"],
["Baz", "789"]
],
response_headers: [
["Expires", http_date(5000)],
["Last-Modified", http_date(-3000)],
["Vary", "*"]
]
},
{
request_headers: [
["*", "1"],
["Baz", "789"]
],
expected_type: "not_cached"
}
]