diff --git a/fetch/OWNERS b/fetch/OWNERS
index fc77aca1b02c91..64550d0d4e4f8c 100644
--- a/fetch/OWNERS
+++ b/fetch/OWNERS
@@ -1,3 +1,4 @@
@jdm
@youennf
@annevk
+@mnot
diff --git a/fetch/http-cache/304-update.html b/fetch/http-cache/304-update.html
new file mode 100644
index 00000000000000..663191a8785721
--- /dev/null
+++ b/fetch/http-cache/304-update.html
@@ -0,0 +1,124 @@
+
+
+
+
+ HTTP Cache - 304 Updates
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/README.md b/fetch/http-cache/README.md
new file mode 100644
index 00000000000000..288672236c1d82
--- /dev/null
+++ b/fetch/http-cache/README.md
@@ -0,0 +1,24 @@
+## HTTP Caching Tests
+
+These tests cover HTTP-specified behaviours for caches, primarily from
+[RFC7234](http://httpwg.org/specs/rfc7234.html), but as seen through the
+lens of Fetch.
+
+A few notes:
+
+* By its nature, caching is optional; some tests expecting a response to be
+ cached might fail because the client chose not to cache it, or chose to
+ race the cache with a network request.
+
+* Likewise, some tests might fail because there is a separate document-level
+ cache that's ill-defined; see [this
+ issue](https://github.com/whatwg/fetch/issues/354).
+
+* [Partial content tests](partial.html) (a.k.a. Range requests) are not specified
+ in Fetch; tests are included here for interest only.
+
+* Some browser caches will behave differently when reloading /
+ shift-reloading, despite the `cache mode` staying the same.
+
+* At the moment, Edge doesn't appear to using HTTP caching in conjunction
+ with Fetch at all.
diff --git a/fetch/http-cache/cc-request.html b/fetch/http-cache/cc-request.html
new file mode 100644
index 00000000000000..05d6f6b8c0983e
--- /dev/null
+++ b/fetch/http-cache/cc-request.html
@@ -0,0 +1,212 @@
+
+
+
+
+ HTTP Cache - Cache-Control Request Directives
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/freshness.html b/fetch/http-cache/freshness.html
new file mode 100644
index 00000000000000..e15d1b42c92aa4
--- /dev/null
+++ b/fetch/http-cache/freshness.html
@@ -0,0 +1,226 @@
+
+
+
+
+ HTTP Cache - Freshness
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/heuristic.html b/fetch/http-cache/heuristic.html
new file mode 100644
index 00000000000000..429dddace6afb1
--- /dev/null
+++ b/fetch/http-cache/heuristic.html
@@ -0,0 +1,104 @@
+
+
+
+
+ HTTP Cache - Heuristic Freshness
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/http-cache.js b/fetch/http-cache/http-cache.js
new file mode 100644
index 00000000000000..afe008959cabcc
--- /dev/null
+++ b/fetch/http-cache/http-cache.js
@@ -0,0 +1,285 @@
+/**
+ * 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 "resources/http-cache.py?token=" + uuid + "&info=" + btoa(JSON.stringify(requests)) + arg;
+}
+
+function server_state(uuid) {
+ return fetch("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"];
+ }
+ return fetch(url, init)
+ .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;
+ }
+}
\ No newline at end of file
diff --git a/fetch/http-cache/invalidate.html b/fetch/http-cache/invalidate.html
new file mode 100644
index 00000000000000..3f2307396977e7
--- /dev/null
+++ b/fetch/http-cache/invalidate.html
@@ -0,0 +1,245 @@
+
+
+
+
+ HTTP Cache - Invalidation
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/partial.html b/fetch/http-cache/partial.html
new file mode 100644
index 00000000000000..3ad593375ac67c
--- /dev/null
+++ b/fetch/http-cache/partial.html
@@ -0,0 +1,109 @@
+
+
+
+
+ HTTP Cache - Partial Content
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/resources/http-cache.py b/fetch/http-cache/resources/http-cache.py
new file mode 100644
index 00000000000000..aedd52e51aef88
--- /dev/null
+++ b/fetch/http-cache/resources/http-cache.py
@@ -0,0 +1,51 @@
+from json import JSONEncoder, JSONDecoder
+from base64 import b64decode
+
+def main(request, response):
+ uuid = request.GET.first("token", None)
+ if "querystate" in request.GET:
+ response.headers.set("Content-Type", "text/plain")
+ return JSONEncoder().encode(request.server.stash.take(uuid))
+
+ server_state = request.server.stash.take(uuid)
+ if not server_state:
+ server_state = []
+
+ requests = JSONDecoder().decode(b64decode(request.GET.first("info", "")))
+ config = requests[len(server_state)]
+
+ state = dict()
+ state["request_method"] = request.method
+ state["request_headers"] = dict([[h.lower(), request.headers[h]] for h in request.headers])
+ server_state.append(state)
+ request.server.stash.put(uuid, server_state)
+
+ note_headers = ['content-type', 'access-control-allow-origin', 'last-modified', 'etag']
+ noted_headers = {}
+ for header in config.get('response_headers', []):
+ if header[0].lower() in ["location", "content-location"]: # magic!
+ header[1] = "%s&target=%s" % (request.url, header[1])
+ response.headers.set(header[0], header[1])
+ if header[0].lower() in note_headers:
+ noted_headers[header[0].lower()] = header[1]
+
+ if "access-control-allow-origin" not in noted_headers:
+ response.headers.set("Access-Control-Allow-Origin", "*");
+ if "content-type" not in noted_headers:
+ response.headers.set("Content-Type", "text/plain")
+ response.headers.set("Server-Request-Count", len(server_state))
+
+ code, phrase = config.get("response_status", [200, "OK"])
+
+ if request.headers.get("If-Modified-Since", False) == noted_headers.get('last-modified', True):
+ code, phrase = [304, "Not Modified"]
+ if request.headers.get("If-None-Match", False) == noted_headers.get('etag', True):
+ code, phrase = [304, "Not Modified"]
+
+ response.status = (code, phrase)
+
+ content = config.get("response_body", uuid)
+ if code in [204, 304]:
+ return ""
+ else:
+ return content
diff --git a/fetch/http-cache/status.html b/fetch/http-cache/status.html
new file mode 100644
index 00000000000000..f60099a85a306f
--- /dev/null
+++ b/fetch/http-cache/status.html
@@ -0,0 +1,69 @@
+
+
+
+
+ HTTP Cache - Status Codes
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fetch/http-cache/vary.html b/fetch/http-cache/vary.html
new file mode 100644
index 00000000000000..2f4b945b0af50b
--- /dev/null
+++ b/fetch/http-cache/vary.html
@@ -0,0 +1,270 @@
+
+
+
+
+ HTTP Cache - Vary
+
+
+
+
+
+
+
+
+
+
+