Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 274 insertions, 0 deletions

diff --git a/testing/web-platform/tests/fetch/http-cache/http-cache.js b/testing/web-platform/tests/fetch/http-cache/http-cache.js
new file mode 100644
index 0000000000..19f1ca9b2b
--- /dev/null
+++ b/testing/web-platform/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
+  }
+}