mozilla-central/testing/web-platform/tests/service-workers/cache-storage/cache-match.https.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

// META: title=Cache.match
// META: global=window,worker
// META: script=./resources/test-helpers.js
// META: script=/common/get-host-info.sub.js
// META: timeout=long
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match('not-present-in-the-cache')
.then(function(result) {
assert_equals(result, undefined,
'Cache.match failures should resolve with undefined.');
});
}, 'Cache.match with no matching entries');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(entries.a.request.url)
.then(function(result) {
assert_response_equals(result, entries.a.response,
'Cache.match should match by URL.');
});
}, 'Cache.match with URL');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(entries.a.request)
.then(function(result) {
assert_response_equals(result, entries.a.response,
'Cache.match should match by Request.');
});
}, 'Cache.match with Request');
prepopulated_cache_test(simple_entries, function(cache, entries) {
var alt_response = new Response('', {status: 201});
return self.caches.open('second_matching_cache')
.then(function(cache) {
return cache.put(entries.a.request, alt_response.clone());
})
.then(function() {
return cache.match(entries.a.request);
})
.then(function(result) {
assert_response_equals(
result, entries.a.response,
'Cache.match should match the first cache.');
});
}, 'Cache.match with multiple cache hits');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(new Request(entries.a.request.url))
.then(function(result) {
assert_response_equals(result, entries.a.response,
'Cache.match should match by Request.');
});
}, 'Cache.match with new Request');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(new Request(entries.a.request.url, {method: 'HEAD'}))
.then(function(result) {
assert_equals(result, undefined,
'Cache.match should not match HEAD Request.');
});
}, 'Cache.match with HEAD');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(entries.a.request,
{ignoreSearch: true})
.then(function(result) {
assert_response_in_array(
result,
[
entries.a.response,
entries.a_with_query.response
],
'Cache.match with ignoreSearch should ignore the ' +
'search parameters of cached request.');
});
},
'Cache.match with ignoreSearch option (request with no search ' +
'parameters)');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(entries.a_with_query.request,
{ignoreSearch: true})
.then(function(result) {
assert_response_in_array(
result,
[
entries.a.response,
entries.a_with_query.response
],
'Cache.match with ignoreSearch should ignore the ' +
'search parameters of request.');
});
},
'Cache.match with ignoreSearch option (request with search parameter)');
cache_test(function(cache) {
var request = new Request('http://example.com/');
var head_request = new Request('http://example.com/', {method: 'HEAD'});
var response = new Response('foo');
return cache.put(request.clone(), response.clone())
.then(function() {
return cache.match(head_request.clone());
})
.then(function(result) {
assert_equals(
result, undefined,
'Cache.match should resolve as undefined with a ' +
'mismatched method.');
return cache.match(head_request.clone(),
{ignoreMethod: true});
})
.then(function(result) {
assert_response_equals(
result, response,
'Cache.match with ignoreMethod should ignore the ' +
'method of request.');
});
}, 'Cache.match supports ignoreMethod');
cache_test(function(cache) {
var vary_request = new Request('http://example.com/c',
{headers: {'Cookies': 'is-for-cookie'}});
var vary_response = new Response('', {headers: {'Vary': 'Cookies'}});
var mismatched_vary_request = new Request('http://example.com/c');
return cache.put(vary_request.clone(), vary_response.clone())
.then(function() {
return cache.match(mismatched_vary_request.clone());
})
.then(function(result) {
assert_equals(
result, undefined,
'Cache.match should resolve as undefined with a ' +
'mismatched vary.');
return cache.match(mismatched_vary_request.clone(),
{ignoreVary: true});
})
.then(function(result) {
assert_response_equals(
result, vary_response,
'Cache.match with ignoreVary should ignore the ' +
'vary of request.');
});
}, 'Cache.match supports ignoreVary');
cache_test(function(cache) {
let has_cache_name = false;
const opts = {
get cacheName() {
has_cache_name = true;
return undefined;
}
};
return self.caches.open('foo')
.then(function() {
return cache.match('bar', opts);
})
.then(function() {
assert_false(has_cache_name,
'Cache.match does not support cacheName option ' +
'which was removed in CacheQueryOptions.');
});
}, 'Cache.match does not support cacheName option');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match(entries.cat.request.url + '#mouse')
.then(function(result) {
assert_response_equals(result, entries.cat.response,
'Cache.match should ignore URL fragment.');
});
}, 'Cache.match with URL containing fragment');
prepopulated_cache_test(simple_entries, function(cache, entries) {
return cache.match('http')
.then(function(result) {
assert_equals(
result, undefined,
'Cache.match should treat query as a URL and not ' +
'just a string fragment.');
});
}, 'Cache.match with string fragment "http" as query');
prepopulated_cache_test(vary_entries, function(cache, entries) {
return cache.match('http://example.com/c')
.then(function(result) {
assert_response_in_array(
result,
[
entries.vary_cookie_absent.response
],
'Cache.match should honor "Vary" header.');
});
}, 'Cache.match with responses containing "Vary" header');
cache_test(function(cache) {
var request = new Request('http://example.com');
var response;
var request_url = new URL('./resources/simple.txt', location.href).href;
return fetch(request_url)
.then(function(fetch_result) {
response = fetch_result;
assert_equals(
response.url, request_url,
'Reponse.url should return the URL of the response.');
return cache.put(request, response.clone());
})
.then(function() {
return cache.match(request.url);
})
.then(function(result) {
assert_response_equals(
result, response,
'Cache.match should return a Response object that has the same ' +
'properties as the stored response.');
return cache.match(response.url);
})
.then(function(result) {
assert_equals(
result, undefined,
'Cache.match should not match cache entry based on response URL.');
});
}, 'Cache.match with Request and Response objects with different URLs');
cache_test(function(cache) {
var request_url = new URL('./resources/simple.txt', location.href).href;
return fetch(request_url)
.then(function(fetch_result) {
return cache.put(new Request(request_url), fetch_result);
})
.then(function() {
return cache.match(request_url);
})
.then(function(result) {
return result.text();
})
.then(function(body_text) {
assert_equals(body_text, 'a simple text file\n',
'Cache.match should return a Response object with a ' +
'valid body.');
})
.then(function() {
return cache.match(request_url);
})
.then(function(result) {
return result.text();
})
.then(function(body_text) {
assert_equals(body_text, 'a simple text file\n',
'Cache.match should return a Response object with a ' +
'valid body each time it is called.');
});
}, 'Cache.match invoked multiple times for the same Request/Response');
cache_test(function(cache) {
var request_url = new URL('./resources/simple.txt', location.href).href;
return fetch(request_url)
.then(function(fetch_result) {
return cache.put(new Request(request_url), fetch_result);
})
.then(function() {
return cache.match(request_url);
})
.then(function(result) {
return result.blob();
})
.then(function(blob) {
var sliced = blob.slice(2,8);
return new Promise(function (resolve, reject) {
var reader = new FileReader();
reader.onloadend = function(event) {
resolve(event.target.result);
};
reader.readAsText(sliced);
});
})
.then(function(text) {
assert_equals(text, 'simple',
'A Response blob returned by Cache.match should be ' +
'sliceable.' );
});
}, 'Cache.match blob should be sliceable');
prepopulated_cache_test(simple_entries, function(cache, entries) {
var request = new Request(entries.a.request.clone(), {method: 'POST'});
return cache.match(request)
.then(function(result) {
assert_equals(result, undefined,
'Cache.match should not find a match');
});
}, 'Cache.match with POST Request');
prepopulated_cache_test(simple_entries, function(cache, entries) {
var response = entries.non_2xx_response.response;
return cache.match(entries.non_2xx_response.request.url)
.then(function(result) {
assert_response_equals(
result, entries.non_2xx_response.response,
'Cache.match should return a Response object that has the ' +
'same properties as a stored non-2xx response.');
});
}, 'Cache.match with a non-2xx Response');
prepopulated_cache_test(simple_entries, function(cache, entries) {
var response = entries.error_response.response;
return cache.match(entries.error_response.request.url)
.then(function(result) {
assert_response_equals(
result, entries.error_response.response,
'Cache.match should return a Response object that has the ' +
'same properties as a stored network error response.');
});
}, 'Cache.match with a network error Response');
cache_test(function(cache) {
// This test validates that we can get a Response from the Cache API,
// clone it, and read just one side of the clone. This was previously
// bugged in FF for Responses with large bodies.
var data = [];
data.length = 80 * 1024;
data.fill('F');
var response;
return cache.put('/', new Response(data.toString()))
.then(function(result) {
return cache.match('/');
})
.then(function(r) {
// Make sure the original response is not GC'd.
response = r;
// Return only the clone. We purposefully test that the other
// half of the clone does not need to be read here.
return response.clone().text();
})
.then(function(text) {
assert_equals(text, data.toString(), 'cloned body text can be read correctly');
});
}, 'Cache produces large Responses that can be cloned and read correctly.');
cache_test(async (cache) => {
const url = get_host_info().HTTPS_REMOTE_ORIGIN +
'/service-workers/cache-storage/resources/simple.txt?pipe=' +
'header(access-control-allow-origin,*)|' +
'header(access-control-expose-headers,*)|' +
'header(foo,bar)|' +
'header(set-cookie,X)';
const response = await fetch(url);
await cache.put(new Request(url), response);
const cached_response = await cache.match(url);
const headers = cached_response.headers;
assert_equals(headers.get('access-control-expose-headers'), '*');
assert_equals(headers.get('foo'), 'bar');
assert_equals(headers.get('set-cookie'), null);
}, 'cors-exposed header should be stored correctly.');
cache_test(async (cache) => {
// A URL that should load a resource with a known mime type.
const url = '/service-workers/cache-storage/resources/blank.html';
const expected_mime_type = 'text/html';
// Verify we get the expected mime type from the network. Note,
// we cannot use an exact match here since some browsers append
// character encoding information to the blob.type value.
const net_response = await fetch(url);
const net_mime_type = (await net_response.blob()).type;
assert_true(net_mime_type.includes(expected_mime_type),
'network response should include the expected mime type');
// Verify we get the exact same mime type when reading the same
// URL resource back out of the cache.
await cache.add(url);
const cache_response = await cache.match(url);
const cache_mime_type = (await cache_response.blob()).type;
assert_equals(cache_mime_type, net_mime_type,
'network and cache response mime types should match');
}, 'MIME type should be set from content-header correctly.');
cache_test(async (cache) => {
const url = '/dummy';
const original_type = 'text/html';
const override_type = 'text/plain';
const init_with_headers = {
headers: {
'content-type': original_type
}
}
// Verify constructing a synthetic response with a content-type header
// gets the correct mime type.
const response = new Response('hello world', init_with_headers);
const original_response_type = (await response.blob()).type;
assert_true(original_response_type.includes(original_type),
'original response should include the expected mime type');
// Verify overwriting the content-type header changes the mime type.
const overwritten_response = new Response('hello world', init_with_headers);
overwritten_response.headers.set('content-type', override_type);
const overwritten_response_type = (await overwritten_response.blob()).type;
assert_equals(overwritten_response_type, override_type,
'mime type can be overridden');
// Verify the Response read from Cache uses the original mime type
// computed when it was first constructed.
const tmp = new Response('hello world', init_with_headers);
tmp.headers.set('content-type', override_type);
await cache.put(url, tmp);
const cache_response = await cache.match(url);
const cache_mime_type = (await cache_response.blob()).type;
assert_equals(cache_mime_type, override_type,
'overwritten and cached response mime types should match');
}, 'MIME type should reflect Content-Type headers of response.');
cache_test(async (cache) => {
const url = new URL('./resources/vary.py?vary=foo',
get_host_info().HTTPS_REMOTE_ORIGIN + self.location.pathname);
const original_request = new Request(url, { mode: 'no-cors',
headers: { 'foo': 'bar' } });
const fetch_response = await fetch(original_request);
assert_equals(fetch_response.type, 'opaque');
await cache.put(original_request, fetch_response);
const match_response_1 = await cache.match(original_request);
assert_not_equals(match_response_1, undefined);
// Verify that cache.match() finds the entry even if queried with a varied
// header that does not match the cache key. Vary headers should be ignored
// for opaque responses.
const different_request = new Request(url, { headers: { 'foo': 'CHANGED' } });
const match_response_2 = await cache.match(different_request);
assert_not_equals(match_response_2, undefined);
}, 'Cache.match ignores vary headers on opaque response.');
done();