tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_stale-while-revalidate_negative.js (2515B)

      1 /*
      2 
      3 Tests the Cache-control: stale-while-revalidate response directive.
      4 
      5 Purpose is to check we DON'T perform the background revalidation when we make the
      6 request past the reval window.
      7 
      8 * Make request #1.
      9  - response is from the server and version=1
     10  - max-age=1, stale-while-revalidate=1
     11 * Switch version of the data on the server.
     12 * Make request #2 in 3 seconds (entry should be expired by that time and no longer
     13  fall into the reval window.)
     14  - response is from the server, version=2
     15 * Done.
     16 
     17 */
     18 
     19 "use strict";
     20 
     21 const { HttpServer } = ChromeUtils.importESModule(
     22  "resource://testing-common/httpd.sys.mjs"
     23 );
     24 
     25 let max_age;
     26 let version;
     27 let generate_response = ver => `response version=${ver}`;
     28 
     29 function test_handler(metadata, response) {
     30  const originalBody = generate_response(version);
     31  response.setHeader("Content-Type", "text/html", false);
     32  response.setHeader(
     33    "Cache-control",
     34    `max-age=${max_age}, stale-while-revalidate=1`,
     35    false
     36  );
     37  response.setStatusLine(metadata.httpVersion, 200, "OK");
     38  response.bodyOutputStream.write(originalBody, originalBody.length);
     39 }
     40 
     41 function make_channel(url) {
     42  return NetUtil.newChannel({
     43    uri: url,
     44    loadUsingSystemPrincipal: true,
     45  }).QueryInterface(Ci.nsIHttpChannel);
     46 }
     47 
     48 async function get_response(channel, fromCache) {
     49  return new Promise(resolve => {
     50    channel.asyncOpen(
     51      new ChannelListener((request, buffer, ctx, isFromCache) => {
     52        Assert.equal(
     53          fromCache,
     54          isFromCache,
     55          `got response from cache = ${fromCache}`
     56        );
     57        resolve(buffer);
     58      })
     59    );
     60  });
     61 }
     62 
     63 async function sleep(time) {
     64  return new Promise(resolve => {
     65    do_timeout(time * 1000, resolve);
     66  });
     67 }
     68 
     69 async function stop_server(httpserver) {
     70  return new Promise(resolve => {
     71    httpserver.stop(resolve);
     72  });
     73 }
     74 
     75 add_task(async function () {
     76  let httpserver = new HttpServer();
     77  httpserver.registerPathHandler("/testdir", test_handler);
     78  httpserver.start(-1);
     79  const PORT = httpserver.identity.primaryPort;
     80  const URI = `http://localhost:${PORT}/testdir`;
     81 
     82  let response;
     83 
     84  version = 1;
     85  max_age = 1;
     86  response = await get_response(make_channel(URI), false);
     87  Assert.equal(response, generate_response(1), "got response ver 1");
     88 
     89  await sleep(max_age + 1 /* stale window */ + 1 /* to expire the window */);
     90 
     91  version = 2;
     92  response = await get_response(make_channel(URI), false);
     93  Assert.equal(response, generate_response(2), "got response ver 2");
     94 
     95  await stop_server(httpserver);
     96 });