html/cross-origin-embedder-policy/credentialless/cache-storage.tentative.https.html

<meta name="timeout" content="long">
<meta name="variant" content="?document">
<meta name="variant" content="?dedicated_worker">
<meta name="variant" content="?shared_worker">
<meta name="variant" content="?service_worker">
<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/common.js"></script>
<script src="./resources/dispatcher.js"></script>
<script>

// Fetch a resource and store it into CacheStorage from |storer| context. Then
// check if it can be retrieved via CacheStorage.match from |retriever| context.
const cacheStorageTest = (
  description,
  storer,
  retriever,
  resource_headers,
  expectation
) => {
  promise_test_parallel(async test => {
    const cross_origin = get_host_info().HTTPS_REMOTE_ORIGIN;
    const url = cross_origin + "/common/square.png?pipe=" + resource_headers +
      `&${token()}`;
    const this_token = token();

    // Fetch a request from |stored|. Store the opaque response into
    // CacheStorage.
    send(storer, `
      const cache = await caches.open("v1");
      const fetch_request = new Request("${url}", {mode: 'no-cors'});
      const fetch_response = await fetch(fetch_request);
      await cache.put(fetch_request, fetch_response);
      send("${this_token}", "stored");
    `);
    assert_equals(await receive(this_token), "stored");

    // Retrieved it from |retriever|.
    send(retriever, `
      const cache = await caches.open("v1");
      try {
        const response = await cache.match("${url}");
        send("${this_token}", "retrieved");
      } catch (error) {
        send("${this_token}", "error");
      }
    `);
    assert_equals(await receive(this_token), expectation);
  }, description);
};

// Execute the same set of tests for every type of execution contexts:
// Documents, DedicatedWorkers, SharedWorkers, and ServiceWorkers. The results
// should be independent of the context.
const environment = location.search.substr(1);
const constructor = environments[environment];

const context_none = constructor(coep_none);
const context_credentialless = constructor(coep_credentialless);
const context_require_corp = constructor(coep_require_corp);

cacheStorageTest(`[${environment}] unsafe-none => unsafe-none`,
  context_none, context_none, "", "retrieved");
cacheStorageTest(`[${environment}] unsafe-none => credentialless`,
  context_none, context_credentialless, "", "error");
cacheStorageTest(`[${environment}] unsafe-none => credentialless + CORP`,
  context_none, context_credentialless, corp_cross_origin, "retrieved");
cacheStorageTest(`[${environment}] unsafe-none => require-corp`,
  context_none, context_require_corp, "", "error");
cacheStorageTest(`[${environment}] unsafe-none => require-corp + CORP`,
  context_none, context_require_corp, corp_cross_origin, "retrieved");

cacheStorageTest(`[${environment}] credentialless => unsafe-none`,
  context_credentialless, context_none, "", "retrieved");
cacheStorageTest(`[${environment}] credentialless => credentialless`,
  context_credentialless, context_credentialless, "", "retrieved");
cacheStorageTest(`[${environment}] credentialless => require-corp`,
  context_credentialless, context_require_corp, "", "error");
cacheStorageTest(`[${environment}] credentialless => require-corp + CORP`,
  context_credentialless, context_require_corp, corp_cross_origin, "retrieved");

cacheStorageTest(`[${environment}] require_corp => unsafe-none`,
  context_require_corp, context_none, corp_cross_origin, "retrieved");
cacheStorageTest(`[${environment}] require_corp => credentialless`,
  context_require_corp, context_credentialless, corp_cross_origin, "retrieved");
cacheStorageTest(`[${environment}] require_corp => require-corp`,
  context_require_corp, context_require_corp, corp_cross_origin, "retrieved");

</script>