tor-browser

test_cache_match_vary.js (16802B)

---

/* 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();
 });