tor-browser

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

test_bug770243.js (6996B)

      1 /* this test does the following:
      2 Always requests the same resource, while for each request getting:
      3 1. 200 + ETag: "one"
      4 2. 401 followed by 200 + ETag: "two"
      5 3. 401 followed by 304
      6 4. 407 followed by 200 + ETag: "three"
      7 5. 407 followed by 304
      8 */
      9 
     10 "use strict";
     11 
     12 const { HttpServer } = ChromeUtils.importESModule(
     13  "resource://testing-common/httpd.sys.mjs"
     14 );
     15 
     16 var httpserv;
     17 
     18 function addCreds(scheme, host) {
     19  var authMgr = Cc["@mozilla.org/network/http-auth-manager;1"].getService(
     20    Ci.nsIHttpAuthManager
     21  );
     22  authMgr.setAuthIdentity(
     23    scheme,
     24    host,
     25    httpserv.identity.primaryPort,
     26    "basic",
     27    "secret",
     28    "/",
     29    "",
     30    "user",
     31    "pass"
     32  );
     33 }
     34 
     35 function clearCreds() {
     36  var authMgr = Cc["@mozilla.org/network/http-auth-manager;1"].getService(
     37    Ci.nsIHttpAuthManager
     38  );
     39  authMgr.clearAll();
     40 }
     41 
     42 function makeChan() {
     43  return NetUtil.newChannel({
     44    uri: "http://localhost:" + httpserv.identity.primaryPort + "/",
     45    loadUsingSystemPrincipal: true,
     46  }).QueryInterface(Ci.nsIHttpChannel);
     47 }
     48 
     49 // Array of handlers that are called one by one in response to expected requests
     50 
     51 var handlers = [
     52  // Test 1
     53  function (metadata, response) {
     54    Assert.equal(metadata.hasHeader("Authorization"), false);
     55    response.setStatusLine(metadata.httpVersion, 200, "OK");
     56    response.setHeader("ETag", '"one"', false);
     57    response.setHeader("Cache-control", "no-cache", false);
     58    response.setHeader("Content-type", "text/plain", false);
     59    var body = "Response body 1";
     60    response.bodyOutputStream.write(body, body.length);
     61  },
     62 
     63  // Test 2
     64  function (metadata, response) {
     65    Assert.equal(metadata.hasHeader("Authorization"), false);
     66    Assert.equal(metadata.getHeader("If-None-Match"), '"one"');
     67    response.setStatusLine(metadata.httpVersion, 401, "Authenticate");
     68    response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
     69    addCreds("http", "localhost");
     70  },
     71  function (metadata, response) {
     72    Assert.equal(metadata.hasHeader("Authorization"), true);
     73    response.setStatusLine(metadata.httpVersion, 200, "OK");
     74    response.setHeader("ETag", '"two"', false);
     75    response.setHeader("Cache-control", "no-cache", false);
     76    response.setHeader("Content-type", "text/plain", false);
     77    var body = "Response body 2";
     78    response.bodyOutputStream.write(body, body.length);
     79    clearCreds();
     80  },
     81 
     82  // Test 3
     83  function (metadata, response) {
     84    Assert.equal(metadata.hasHeader("Authorization"), false);
     85    Assert.equal(metadata.getHeader("If-None-Match"), '"two"');
     86    response.setStatusLine(metadata.httpVersion, 401, "Authenticate");
     87    response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
     88    addCreds("http", "localhost");
     89  },
     90  function (metadata, response) {
     91    Assert.equal(metadata.hasHeader("Authorization"), true);
     92    Assert.equal(metadata.getHeader("If-None-Match"), '"two"');
     93    response.setStatusLine(metadata.httpVersion, 304, "OK");
     94    response.setHeader("ETag", '"two"', false);
     95    clearCreds();
     96  },
     97 
     98  // Test 4
     99  function (metadata, response) {
    100    Assert.equal(metadata.hasHeader("Authorization"), false);
    101    Assert.equal(metadata.getHeader("If-None-Match"), '"two"');
    102    response.setStatusLine(metadata.httpVersion, 407, "Proxy Authenticate");
    103    response.setHeader("Proxy-Authenticate", 'Basic realm="secret"', false);
    104    addCreds("http", "localhost");
    105  },
    106  function (metadata, response) {
    107    Assert.equal(metadata.hasHeader("Proxy-Authorization"), true);
    108    Assert.equal(metadata.getHeader("If-None-Match"), '"two"');
    109    response.setStatusLine(metadata.httpVersion, 200, "OK");
    110    response.setHeader("ETag", '"three"', false);
    111    response.setHeader("Cache-control", "no-cache", false);
    112    response.setHeader("Content-type", "text/plain", false);
    113    var body = "Response body 3";
    114    response.bodyOutputStream.write(body, body.length);
    115    clearCreds();
    116  },
    117 
    118  // Test 5
    119  function (metadata, response) {
    120    Assert.equal(metadata.hasHeader("Proxy-Authorization"), false);
    121    Assert.equal(metadata.getHeader("If-None-Match"), '"three"');
    122    response.setStatusLine(metadata.httpVersion, 407, "Proxy Authenticate");
    123    response.setHeader("Proxy-Authenticate", 'Basic realm="secret"', false);
    124    addCreds("http", "localhost");
    125  },
    126  function (metadata, response) {
    127    Assert.equal(metadata.hasHeader("Proxy-Authorization"), true);
    128    Assert.equal(metadata.getHeader("If-None-Match"), '"three"');
    129    response.setStatusLine(metadata.httpVersion, 304, "OK");
    130    response.setHeader("ETag", '"three"', false);
    131    response.setHeader("Cache-control", "no-cache", false);
    132    clearCreds();
    133  },
    134 ];
    135 
    136 function handler(metadata, response) {
    137  handlers.shift()(metadata, response);
    138 }
    139 
    140 // Array of tests to run, self-driven
    141 
    142 function sync_and_run_next_test() {
    143  syncWithCacheIOThread(function () {
    144    tests.shift()();
    145  });
    146 }
    147 
    148 var tests = [
    149  // Test 1: 200 (cacheable)
    150  function () {
    151    var ch = makeChan();
    152    ch.asyncOpen(
    153      new ChannelListener(
    154        function (req, body) {
    155          Assert.equal(body, "Response body 1");
    156          sync_and_run_next_test();
    157        },
    158        null,
    159        CL_NOT_FROM_CACHE
    160      )
    161    );
    162  },
    163 
    164  // Test 2: 401 and 200 + new content
    165  function () {
    166    var ch = makeChan();
    167    ch.asyncOpen(
    168      new ChannelListener(
    169        function (req, body) {
    170          Assert.equal(body, "Response body 2");
    171          sync_and_run_next_test();
    172        },
    173        null,
    174        CL_NOT_FROM_CACHE
    175      )
    176    );
    177  },
    178 
    179  // Test 3: 401 and 304
    180  function () {
    181    var ch = makeChan();
    182    ch.asyncOpen(
    183      new ChannelListener(
    184        function (req, body) {
    185          Assert.equal(body, "Response body 2");
    186          sync_and_run_next_test();
    187        },
    188        null,
    189        CL_FROM_CACHE
    190      )
    191    );
    192  },
    193 
    194  // Test 4: 407 and 200 + new content
    195  function () {
    196    var ch = makeChan();
    197    ch.asyncOpen(
    198      new ChannelListener(
    199        function (req, body) {
    200          Assert.equal(body, "Response body 3");
    201          sync_and_run_next_test();
    202        },
    203        null,
    204        CL_NOT_FROM_CACHE
    205      )
    206    );
    207  },
    208 
    209  // Test 5: 407 and 304
    210  function () {
    211    var ch = makeChan();
    212    ch.asyncOpen(
    213      new ChannelListener(
    214        function (req, body) {
    215          Assert.equal(body, "Response body 3");
    216          sync_and_run_next_test();
    217        },
    218        null,
    219        CL_FROM_CACHE
    220      )
    221    );
    222  },
    223 
    224  // End of test run
    225  function () {
    226    httpserv.stop(do_test_finished);
    227  },
    228 ];
    229 
    230 function run_test() {
    231  do_get_profile();
    232 
    233  httpserv = new HttpServer();
    234  httpserv.registerPathHandler("/", handler);
    235  httpserv.start(-1);
    236 
    237  const prefs = Services.prefs;
    238  prefs.setCharPref("network.proxy.http", "localhost");
    239  prefs.setIntPref("network.proxy.http_port", httpserv.identity.primaryPort);
    240  prefs.setBoolPref("network.proxy.allow_hijacking_localhost", true);
    241  prefs.setIntPref("network.proxy.type", 1);
    242  prefs.setBoolPref("network.http.rcwn.enabled", false);
    243 
    244  tests.shift()();
    245  do_test_pending();
    246 }