netwerk/test/unit/test_bug770243.js

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