/* global context testDone:true */
var requestURL =
"//mochi.test:8888/tests/dom/cache/test/mochitest/vary.sjs?" + context;
var name =
"match-vary" + context;
function checkResponse(r, response, responseText) {
ok(r !== response,
"The objects should not be the same");
is(
r.url,
response.url.replace(
"#fragment",
""),
"The URLs should be the same"
);
is(r.status, response.status,
"The status codes should be the same");
is(r.type, response.type,
"The response types should be the same");
is(r.ok, response.ok,
"Both responses should have succeeded");
is(
r.statusText,
response.statusText,
"Both responses should have the same status text"
);
is(
r.headers.get(
"Vary"),
response.headers.get(
"Vary"),
"Both responses should have the same Vary header"
);
return r.text().then(
function (text) {
is(text, responseText,
"The response body should be correct");
});
}
// Returns a Promise that will be resolved to an object with the following
// properties:
// * cache: A Cache object that contains one entry fetched with headers.
// * response: A Response object which is the result of fetching a request
// with the specified headers.
// * responseText: The body of the above response object.
function setupTest(headers) {
return setupTestMultipleEntries([headers]).then(
function (test) {
return {
response: test.response[0],
responseText: test.responseText[0],
cache: test.cache,
};
});
}
function setupTestMultipleEntries(headers) {
ok(Array.isArray(headers),
"headers should be an array");
return new Promise(
function (resolve, reject) {
var response, responseText, cache;
Promise.all(
headers.map(
function (h) {
return fetch(requestURL, { headers: h });
})
)
.then(
function (res) {
response = res;
return Promise.all(
response.map(
function (r) {
return r.text();
})
);
})
.then(
function (text) {
responseText = text;
return caches.open(name);
})
.then(
function (c) {
cache = c;
return Promise.all(
headers.map(
function (h) {
return c.add(
new Request(requestURL, { headers: h }));
})
);
})
.then(
function () {
resolve({ response, responseText, cache });
})
.
catch(
function (err) {
reject(err);
});
});
}
function testBasics() {
var test;
return setupTest({ WhatToVary:
"Custom" })
.then(
function (t) {
test = t;
// Ensure that searching without specifying a Custom header succeeds.
return test.cache.match(requestURL);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that searching with a non-matching value for the Custom header fails.
return test.cache.match(
new Request(requestURL, { headers: { Custom:
"foo=bar" } })
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with an unknown Vary header should not succeed"
);
// Ensure that searching with a non-matching value for the Custom header but with ignoreVary set succeeds.
return test.cache.match(
new Request(requestURL, { headers: { Custom:
"foo=bar" } }),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
});
}
function testBasicKeys() {
function checkRequest(reqs) {
is(reqs.length, 1,
"One request expected");
ok(reqs[0].url.includes(requestURL),
"The correct request expected");
ok(
reqs[0].headers.get(
"WhatToVary"),
"Custom",
"The correct request headers expected"
);
}
var test;
return setupTest({ WhatToVary:
"Custom" })
.then(
function (t) {
test = t;
// Ensure that searching without specifying a Custom header succeeds.
return test.cache.keys(requestURL);
})
.then(
function (r) {
return checkRequest(r);
})
.then(
function () {
// Ensure that searching with a non-matching value for the Custom header fails.
return test.cache.keys(
new Request(requestURL, { headers: { Custom:
"foo=bar" } })
);
})
.then(
function (r) {
is(
r.length,
0,
"Searching for a request with an unknown Vary header should not succeed"
);
// Ensure that searching with a non-matching value for the Custom header but with ignoreVary set succeeds.
return test.cache.keys(
new Request(requestURL, { headers: { Custom:
"foo=bar" } }),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkRequest(r);
});
}
function testStar() {
function ensurePromiseRejected(promise) {
return promise.then(
function () {
ok(
false,
"Promise should be rejected");
},
function (err) {
is(
err.name,
"TypeError",
"Attempting to store a Response with a Vary:* header must fail"
);
}
);
}
return new Promise(
function (resolve, reject) {
var cache;
caches.open(name).then(
function (c) {
cache = c;
Promise.all([
ensurePromiseRejected(
cache.add(
new Request(requestURL +
"1", { headers: { WhatToVary:
"*" } })
)
),
ensurePromiseRejected(
cache.addAll([
new Request(requestURL +
"2", { headers: { WhatToVary:
"*" } }),
requestURL +
"3",
])
),
ensurePromiseRejected(
fetch(
new Request(requestURL +
"4", { headers: { WhatToVary:
"*" } })
).then(
function (response) {
return cache.put(requestURL +
"4", response);
})
),
ensurePromiseRejected(
cache.add(
new Request(requestURL +
"5", {
headers: { WhatToVary:
"*,User-Agent" },
})
)
),
ensurePromiseRejected(
cache.addAll([
new Request(requestURL +
"6", {
headers: { WhatToVary:
"*,User-Agent" },
}),
requestURL +
"7",
])
),
ensurePromiseRejected(
fetch(
new Request(requestURL +
"8", {
headers: { WhatToVary:
"*,User-Agent" },
})
).then(
function (response) {
return cache.put(requestURL +
"8", response);
})
),
ensurePromiseRejected(
cache.add(
new Request(requestURL +
"9", {
headers: { WhatToVary:
"User-Agent,*" },
})
)
),
ensurePromiseRejected(
cache.addAll([
new Request(requestURL +
"10", {
headers: { WhatToVary:
"User-Agent,*" },
}),
requestURL +
"10",
])
),
ensurePromiseRejected(
fetch(
new Request(requestURL +
"11", {
headers: { WhatToVary:
"User-Agent,*" },
})
).then(
function (response) {
return cache.put(requestURL +
"11", response);
})
),
]).then(reject, resolve);
});
});
}
function testMatch() {
var test;
return setupTest({ WhatToVary:
"Custom", Custom:
"foo=bar" })
.then(
function (t) {
test = t;
// Ensure that searching with a different Custom header fails.
return test.cache.match(
new Request(requestURL, { headers: { Custom:
"bar=baz" } })
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with a non-matching Custom header should not succeed"
);
// Ensure that searching with the same Custom header succeeds.
return test.cache.match(
new Request(requestURL, { headers: { Custom:
"foo=bar" } })
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
});
}
function testInvalidHeaderName() {
var test;
return setupTest({ WhatToVary:
"Foo/Bar, Custom-User-Agent" })
.then(
function (t) {
test = t;
// Ensure that searching with a different User-Agent header fails.
return test.cache.match(
new Request(requestURL, { headers: {
"Custom-User-Agent":
"MyUA" } })
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with a non-matching Custom-User-Agent header should not succeed"
);
// Ensure that searching with a different Custom-User-Agent header but with ignoreVary succeeds.
return test.cache.match(
new Request(requestURL, { headers: {
"Custom-User-Agent":
"MyUA" } }),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that we do not mistakenly recognize the tokens in the invalid header name.
return test.cache.match(
new Request(requestURL, { headers: { Foo:
"foobar" } })
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
});
}
function testMultipleHeaders() {
var test;
return setupTest({ WhatToVary:
"Custom-Referer,\tCustom-Accept-Encoding" })
.then(
function (t) {
test = t;
// Ensure that searching with a different Referer header fails.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Referer":
"https://somesite.com/" },
})
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with a non-matching Custom-Referer header should not succeed"
);
// Ensure that searching with a different Custom-Referer header but with ignoreVary succeeds.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Referer":
"https://somesite.com/" },
}),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that searching with a different Custom-Accept-Encoding header fails.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Accept-Encoding":
"myencoding" },
})
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with a non-matching Custom-Accept-Encoding header should not succeed"
);
// Ensure that searching with a different Custom-Accept-Encoding header but with ignoreVary succeeds.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Accept-Encoding":
"myencoding" },
}),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that searching with an empty Custom-Referer header succeeds.
return test.cache.match(
new Request(requestURL, { headers: {
"Custom-Referer":
"" } })
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that searching with an empty Custom-Accept-Encoding header succeeds.
return test.cache.match(
new Request(requestURL, { headers: {
"Custom-Accept-Encoding":
"" } })
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
})
.then(
function () {
// Ensure that searching with an empty Custom-Referer header but with a different Custom-Accept-Encoding header fails.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Referer":
"",
"Custom-Accept-Encoding":
"myencoding",
},
})
);
})
.then(
function (r) {
is(
typeof r,
"undefined",
"Searching for a request with a non-matching Custom-Accept-Encoding header should not succeed"
);
// Ensure that searching with an empty Custom-Referer header but with a different Custom-Accept-Encoding header and ignoreVary succeeds.
return test.cache.match(
new Request(requestURL, {
headers: {
"Custom-Referer":
"",
"Custom-Accept-Encoding":
"myencoding",
},
}),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return checkResponse(r, test.response, test.responseText);
});
}
function testMultipleCacheEntries() {
var test;
return setupTestMultipleEntries([
{ WhatToVary:
"Accept-Language",
"Accept-Language":
"en-US" },
{ WhatToVary:
"Accept-Language",
"Accept-Language":
"en-US, fa-IR" },
])
.then(
function (t) {
test = t;
return test.cache.matchAll();
})
.then(
function (r) {
is(r.length, 2,
"Two cache entries should be stored in the DB");
// Ensure that searching without specifying an Accept-Language header fails.
return test.cache.matchAll(requestURL);
})
.then(
function (r) {
is(
r.length,
0,
"Searching for a request without specifying an Accept-Language header should not succeed"
);
// Ensure that searching without specifying an Accept-Language header but with ignoreVary succeeds.
return test.cache.matchAll(requestURL, { ignoreVary:
true });
})
.then(
function (r) {
return Promise.all([
checkResponse(r[0], test.response[0], test.responseText[0]),
checkResponse(r[1], test.response[1], test.responseText[1]),
]);
})
.then(
function () {
// Ensure that searching with Accept-Language: en-US succeeds.
return test.cache.matchAll(
new Request(requestURL, { headers: {
"Accept-Language":
"en-US" } })
);
})
.then(
function (r) {
is(r.length, 1,
"One cache entry should be found");
return checkResponse(r[0], test.response[0], test.responseText[0]);
})
.then(
function () {
// Ensure that searching with Accept-Language: en-US,fa-IR succeeds.
return test.cache.matchAll(
new Request(requestURL, {
headers: {
"Accept-Language":
"en-US, fa-IR" },
})
);
})
.then(
function (r) {
is(r.length, 1,
"One cache entry should be found");
return checkResponse(r[0], test.response[1], test.responseText[1]);
})
.then(
function () {
// Ensure that searching with a valid Accept-Language header but with ignoreVary returns both entries.
return test.cache.matchAll(
new Request(requestURL, { headers: {
"Accept-Language":
"en-US" } }),
{ ignoreVary:
true }
);
})
.then(
function (r) {
return Promise.all([
checkResponse(r[0], test.response[0], test.responseText[0]),
checkResponse(r[1], test.response[1], test.responseText[1]),
]);
})
.then(
function () {
// Ensure that searching with Accept-Language: fa-IR fails.
return test.cache.matchAll(
new Request(requestURL, { headers: {
"Accept-Language":
"fa-IR" } })
);
})
.then(
function (r) {
is(
r.length,
0,
"Searching for a request with a different Accept-Language header should not succeed"
);
// Ensure that searching with Accept-Language: fa-IR but with ignoreVary should succeed.
return test.cache.matchAll(
new Request(requestURL, { headers: {
"Accept-Language":
"fa-IR" } }),
{ ignoreVary:
true }
);
})
.then(
function (r) {
is(r.length, 2,
"Two cache entries should be found");
return Promise.all([
checkResponse(r[0], test.response[0], test.responseText[0]),
checkResponse(r[1], test.response[1], test.responseText[1]),
]);
});
}
// Make sure to clean up after each test step.
function step(testPromise) {
return testPromise.then(
function () {
caches.
delete(name);
},
function () {
caches.
delete(name);
}
);
}
step(testBasics())
.then(
function () {
return step(testBasicKeys());
})
.then(
function () {
return step(testStar());
})
.then(
function () {
return step(testMatch());
})
.then(
function () {
return step(testInvalidHeaderName());
})
.then(
function () {
return step(testMultipleHeaders());
})
.then(
function () {
return step(testMultipleCacheEntries());
})
.then(
function () {
testDone();
});
