summaryrefslogtreecommitdiffstats
path: root/test/wpt/tests/fetch/http-cache/http-cache.js
diff options
context:
space:
mode:
Diffstat (limited to 'test/wpt/tests/fetch/http-cache/http-cache.js')
-rw-r--r--test/wpt/tests/fetch/http-cache/http-cache.js274
1 files changed, 274 insertions, 0 deletions
diff --git a/test/wpt/tests/fetch/http-cache/http-cache.js b/test/wpt/tests/fetch/http-cache/http-cache.js
new file mode 100644
index 0000000..19f1ca9
--- /dev/null
+++ b/test/wpt/tests/fetch/http-cache/http-cache.js
@@ -0,0 +1,274 @@
+/* global btoa fetch token promise_test step_timeout */
+/* global assert_equals assert_true assert_own_property assert_throws_js assert_less_than */
+
+const templates = {
+ 'fresh': {
+ 'response_headers': [
+ ['Expires', 100000],
+ ['Last-Modified', 0]
+ ]
+ },
+ 'stale': {
+ 'response_headers': [
+ ['Expires', -5000],
+ ['Last-Modified', -100000]
+ ]
+ },
+ 'lcl_response': {
+ 'response_headers': [
+ ['Location', 'location_target'],
+ ['Content-Location', 'content_location_target']
+ ]
+ },
+ 'location': {
+ 'query_arg': 'location_target',
+ 'response_headers': [
+ ['Expires', 100000],
+ ['Last-Modified', 0]
+ ]
+ },
+ 'content_location': {
+ 'query_arg': 'content_location_target',
+ 'response_headers': [
+ ['Expires', 100000],
+ ['Last-Modified', 0]
+ ]
+ }
+}
+
+const noBodyStatus = new Set([204, 304])
+
+function makeTest (test) {
+ return function () {
+ var uuid = token()
+ var requests = expandTemplates(test)
+ var fetchFunctions = makeFetchFunctions(requests, uuid)
+ return runTest(fetchFunctions, requests, uuid)
+ }
+}
+
+function makeFetchFunctions(requests, uuid) {
+ var fetchFunctions = []
+ for (let i = 0; i < requests.length; ++i) {
+ fetchFunctions.push({
+ code: function (idx) {
+ var config = requests[idx]
+ var url = makeTestUrl(uuid, config)
+ var init = fetchInit(requests, config)
+ return fetch(url, init)
+ .then(makeCheckResponse(idx, config))
+ .then(makeCheckResponseBody(config, uuid), function (reason) {
+ if ('expected_type' in config && config.expected_type === 'error') {
+ assert_throws_js(TypeError, function () { throw reason })
+ } else {
+ throw reason
+ }
+ })
+ },
+ pauseAfter: 'pause_after' in requests[i]
+ })
+ }
+ return fetchFunctions
+}
+
+function runTest(fetchFunctions, requests, uuid) {
+ var idx = 0
+ function runNextStep () {
+ if (fetchFunctions.length) {
+ var nextFetchFunction = fetchFunctions.shift()
+ if (nextFetchFunction.pauseAfter === true) {
+ return nextFetchFunction.code(idx++)
+ .then(pause)
+ .then(runNextStep)
+ } else {
+ return nextFetchFunction.code(idx++)
+ .then(runNextStep)
+ }
+ } else {
+ return Promise.resolve()
+ }
+ }
+
+ return runNextStep()
+ .then(function () {
+ return getServerState(uuid)
+ }).then(function (testState) {
+ checkRequests(requests, testState)
+ return Promise.resolve()
+ })
+}
+
+function expandTemplates (test) {
+ var rawRequests = test.requests
+ var requests = []
+ for (let i = 0; i < rawRequests.length; i++) {
+ var request = rawRequests[i]
+ request.name = test.name
+ if ('template' in request) {
+ var template = templates[request['template']]
+ for (let member in template) {
+ if (!request.hasOwnProperty(member)) {
+ request[member] = template[member]
+ }
+ }
+ }
+ requests.push(request)
+ }
+ return requests
+}
+
+function fetchInit (requests, config) {
+ var init = {
+ 'headers': []
+ }
+ if ('request_method' in config) init.method = config['request_method']
+ // Note: init.headers must be a copy of config['request_headers'] array,
+ // because new elements are added later.
+ if ('request_headers' in config) init.headers = [...config['request_headers']];
+ if ('name' in config) init.headers.push(['Test-Name', config.name])
+ if ('request_body' in config) init.body = config['request_body']
+ if ('mode' in config) init.mode = config['mode']
+ if ('credentials' in config) init.credentials = config['credentials']
+ if ('cache' in config) init.cache = config['cache']
+ init.headers.push(['Test-Requests', btoa(JSON.stringify(requests))])
+ return init
+}
+
+function makeCheckResponse (idx, config) {
+ return function checkResponse (response) {
+ var reqNum = idx + 1
+ var resNum = parseInt(response.headers.get('Server-Request-Count'))
+ if ('expected_type' in config) {
+ if (config.expected_type === 'error') {
+ assert_true(false, `Request ${reqNum} doesn't throw an error`)
+ return response.text()
+ }
+ if (config.expected_type === 'cached') {
+ assert_less_than(resNum, reqNum, `Response ${reqNum} does not come from cache`)
+ }
+ if (config.expected_type === 'not_cached') {
+ assert_equals(resNum, reqNum, `Response ${reqNum} comes from cache`)
+ }
+ }
+ if ('expected_status' in config) {
+ assert_equals(response.status, config.expected_status,
+ `Response ${reqNum} status is ${response.status}, not ${config.expected_status}`)
+ } else if ('response_status' in config) {
+ assert_equals(response.status, config.response_status[0],
+ `Response ${reqNum} status is ${response.status}, not ${config.response_status[0]}`)
+ } else {
+ assert_equals(response.status, 200, `Response ${reqNum} status is ${response.status}, not 200`)
+ }
+ 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 ${reqNum} header ${header[0]} is "${response.headers.get(header[0])}", not "${header[1]}"`)
+ }
+ })
+ }
+ if ('expected_response_headers' in config) {
+ config.expected_response_headers.forEach(function (header) {
+ assert_equals(response.headers.get(header[0]), header[1],
+ `Response ${reqNum} header ${header[0]} is "${response.headers.get(header[0])}", not "${header[1]}"`)
+ })
+ }
+ return response.text()
+ }
+}
+
+function makeCheckResponseBody (config, uuid) {
+ return function checkResponseBody (resBody) {
+ var statusCode = 200
+ if ('response_status' in config) {
+ statusCode = config.response_status[0]
+ }
+ if ('expected_response_text' in config) {
+ if (config.expected_response_text !== null) {
+ assert_equals(resBody, config.expected_response_text,
+ `Response body is "${resBody}", not expected "${config.expected_response_text}"`)
+ }
+ } else if ('response_body' in config && config.response_body !== null) {
+ assert_equals(resBody, config.response_body,
+ `Response body is "${resBody}", not sent "${config.response_body}"`)
+ } else if (!noBodyStatus.has(statusCode)) {
+ assert_equals(resBody, uuid, `Response body is "${resBody}", not default "${uuid}"`)
+ }
+ }
+}
+
+function checkRequests (requests, testState) {
+ var testIdx = 0
+ for (let i = 0; i < requests.length; ++i) {
+ var expectedValidatingHeaders = []
+ var config = requests[i]
+ var serverRequest = testState[testIdx]
+ var reqNum = i + 1
+ if ('expected_type' in config) {
+ if (config.expected_type === 'cached') continue // the server will not see the request
+ if (config.expected_type === 'etag_validated') {
+ expectedValidatingHeaders.push('if-none-match')
+ }
+ if (config.expected_type === 'lm_validated') {
+ expectedValidatingHeaders.push('if-modified-since')
+ }
+ }
+ testIdx++
+ expectedValidatingHeaders.forEach(vhdr => {
+ assert_own_property(serverRequest.request_headers, vhdr,
+ `request ${reqNum} doesn't have ${vhdr} header`)
+ })
+ if ('expected_request_headers' in config) {
+ config.expected_request_headers.forEach(expectedHdr => {
+ assert_equals(serverRequest.request_headers[expectedHdr[0].toLowerCase()], expectedHdr[1],
+ `request ${reqNum} header ${expectedHdr[0]} value is "${serverRequest.request_headers[expectedHdr[0].toLowerCase()]}", not "${expectedHdr[1]}"`)
+ })
+ }
+ }
+}
+
+function pause () {
+ return new Promise(function (resolve, reject) {
+ step_timeout(function () {
+ return resolve()
+ }, 3000)
+ })
+}
+
+function makeTestUrl (uuid, config) {
+ var arg = ''
+ var base_url = ''
+ if ('base_url' in config) {
+ base_url = config.base_url
+ }
+ if ('query_arg' in config) {
+ arg = `&target=${config.query_arg}`
+ }
+ return `${base_url}resources/http-cache.py?dispatch=test&uuid=${uuid}${arg}`
+}
+
+function getServerState (uuid) {
+ return fetch(`resources/http-cache.py?dispatch=state&uuid=${uuid}`)
+ .then(function (response) {
+ return response.text()
+ }).then(function (text) {
+ return JSON.parse(text) || []
+ })
+}
+
+function run_tests (tests) {
+ tests.forEach(function (test) {
+ promise_test(makeTest(test), test.name)
+ })
+}
+
+var contentStore = {}
+function http_content (csKey) {
+ if (csKey in contentStore) {
+ return contentStore[csKey]
+ } else {
+ var content = btoa(Math.random() * Date.now())
+ contentStore[csKey] = content
+ return content
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-08 13:09:19 +0000