netwerk/test/unit/test_http2.js

   1 /* import-globals-from http2_test_common.js */
   2
   3 const { HttpServer } = ChromeUtils.importESModule(
   4   "resource://testing-common/httpd.sys.mjs"
   5 );
   6
   7 var concurrent_channels = [];
   8 var httpserv = null;
   9 var httpserv2 = null;
  10
  11 var loadGroup;
  12 var serverPort;
  13
  14 function altsvcHttp1Server(metadata, response) {
  15   response.setStatusLine(metadata.httpVersion, 200, "OK");
  16   response.setHeader("Content-Type", "text/plain", false);
  17   response.setHeader("Connection", "close", false);
  18   response.setHeader("Alt-Svc", 'h2=":' + serverPort + '"', false);
  19   var body = "this is where a cool kid would write something neat.\n";
  20   response.bodyOutputStream.write(body, body.length);
  21 }
  22
  23 function h1ServerWK(metadata, response) {
  24   response.setStatusLine(metadata.httpVersion, 200, "OK");
  25   response.setHeader("Content-Type", "application/json", false);
  26   response.setHeader("Connection", "close", false);
  27   response.setHeader("Cache-Control", "no-cache", false);
  28   response.setHeader("Access-Control-Allow-Origin", "*", false);
  29   response.setHeader("Access-Control-Allow-Method", "GET", false);
  30
  31   var body = '["http://foo.example.com:' + httpserv.identity.primaryPort + '"]';
  32   response.bodyOutputStream.write(body, body.length);
  33 }
  34
  35 function altsvcHttp1Server2(metadata, response) {
  36   // this server should never be used thanks to an alt svc frame from the
  37   // h2 server.. but in case of some async lag in setting the alt svc route
  38   // up we have it.
  39   response.setStatusLine(metadata.httpVersion, 200, "OK");
  40   response.setHeader("Content-Type", "text/plain", false);
  41   response.setHeader("Connection", "close", false);
  42   var body = "hanging.\n";
  43   response.bodyOutputStream.write(body, body.length);
  44 }
  45
  46 function h1ServerWK2(metadata, response) {
  47   response.setStatusLine(metadata.httpVersion, 200, "OK");
  48   response.setHeader("Content-Type", "application/json", false);
  49   response.setHeader("Connection", "close", false);
  50   response.setHeader("Cache-Control", "no-cache", false);
  51   response.setHeader("Access-Control-Allow-Origin", "*", false);
  52   response.setHeader("Access-Control-Allow-Method", "GET", false);
  53
  54   var body =
  55     '["http://foo.example.com:' + httpserv2.identity.primaryPort + '"]';
  56   response.bodyOutputStream.write(body, body.length);
  57 }
  58
  59 add_setup(async function setup() {
  60   serverPort = Services.env.get("MOZHTTP2_PORT");
  61   Assert.notEqual(serverPort, null);
  62   dump("using port " + serverPort + "\n");
  63
  64   // Set to allow the cert presented by our H2 server
  65   do_get_profile();
  66
  67   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 0);
  68
  69   // The moz-http2 cert is for foo.example.com and is signed by http2-ca.pem
  70   // so add that cert to the trust list as a signing cert. Some older tests in
  71   // this suite use localhost with a TOFU exception, but new ones should use
  72   // foo.example.com
  73   let certdb = Cc["@mozilla.org/security/x509certdb;1"].getService(
  74     Ci.nsIX509CertDB
  75   );
  76   addCertFromFile(certdb, "http2-ca.pem", "CTu,u,u");
  77
  78   Services.prefs.setBoolPref("network.http.http2.enabled", true);
  79   Services.prefs.setBoolPref("network.http.http2.allow-push", true);
  80   Services.prefs.setBoolPref("network.http.altsvc.enabled", true);
  81   Services.prefs.setBoolPref("network.http.altsvc.oe", true);
  82   Services.prefs.setCharPref(
  83     "network.dns.localDomains",
  84     "foo.example.com, bar.example.com"
  85   );
  86   Services.prefs.setBoolPref(
  87     "network.cookieJarSettings.unblocked_for_testing",
  88     true
  89   );
  90
  91   loadGroup = Cc["@mozilla.org/network/load-group;1"].createInstance(
  92     Ci.nsILoadGroup
  93   );
  94
  95   httpserv = new HttpServer();
  96   httpserv.registerPathHandler("/altsvc1", altsvcHttp1Server);
  97   httpserv.registerPathHandler("/.well-known/http-opportunistic", h1ServerWK);
  98   httpserv.start(-1);
  99   httpserv.identity.setPrimary(
 100     "http",
 101     "foo.example.com",
 102     httpserv.identity.primaryPort
 103   );
 104
 105   httpserv2 = new HttpServer();
 106   httpserv2.registerPathHandler("/altsvc2", altsvcHttp1Server2);
 107   httpserv2.registerPathHandler("/.well-known/http-opportunistic", h1ServerWK2);
 108   httpserv2.start(-1);
 109   httpserv2.identity.setPrimary(
 110     "http",
 111     "foo.example.com",
 112     httpserv2.identity.primaryPort
 113   );
 114 });
 115
 116 registerCleanupFunction(async () => {
 117   Services.prefs.clearUserPref("network.http.speculative-parallel-limit");
 118   Services.prefs.clearUserPref("network.http.http2.enabled");
 119   Services.prefs.clearUserPref("network.http.http2.allow-push");
 120   Services.prefs.clearUserPref("network.http.altsvc.enabled");
 121   Services.prefs.clearUserPref("network.http.altsvc.oe");
 122   Services.prefs.clearUserPref("network.dns.localDomains");
 123   Services.prefs.clearUserPref(
 124     "network.cookieJarSettings.unblocked_for_testing"
 125   );
 126   await httpserv.stop();
 127   await httpserv2.stop();
 128 });
 129
 130 // hack - the header test resets the multiplex object on the server,
 131 // so make sure header is always run before the multiplex test.
 132 //
 133 // make sure post_big runs first to test race condition in restarting
 134 // a stalled stream when a SETTINGS frame arrives
 135 add_task(async function do_test_http2_post_big() {
 136   const { httpProxyConnectResponseCode } =
 137     await test_http2_post_big(serverPort);
 138   Assert.equal(httpProxyConnectResponseCode, -1);
 139 });
 140
 141 add_task(async function do_test_http2_basic() {
 142   const { httpProxyConnectResponseCode } = await test_http2_basic(serverPort);
 143   Assert.equal(httpProxyConnectResponseCode, -1);
 144 });
 145
 146 add_task(async function do_test_http2_concurrent() {
 147   const { httpProxyConnectResponseCode } = await test_http2_concurrent(
 148     concurrent_channels,
 149     serverPort
 150   );
 151   Assert.equal(httpProxyConnectResponseCode, -1);
 152 });
 153
 154 add_task(async function do_test_http2_concurrent_post() {
 155   const { httpProxyConnectResponseCode } = await test_http2_concurrent_post(
 156     concurrent_channels,
 157     serverPort
 158   );
 159   Assert.equal(httpProxyConnectResponseCode, -1);
 160 });
 161
 162 add_task(async function do_test_http2_basic_unblocked_dep() {
 163   const { httpProxyConnectResponseCode } =
 164     await test_http2_basic_unblocked_dep(serverPort);
 165   Assert.equal(httpProxyConnectResponseCode, -1);
 166 });
 167
 168 add_task(async function do_test_http2_nospdy() {
 169   const { httpProxyConnectResponseCode } = await test_http2_nospdy(serverPort);
 170   Assert.equal(httpProxyConnectResponseCode, -1);
 171 });
 172
 173 add_task(async function do_test_http2_push1() {
 174   const { httpProxyConnectResponseCode } = await test_http2_push1(
 175     loadGroup,
 176     serverPort
 177   );
 178   Assert.equal(httpProxyConnectResponseCode, -1);
 179 });
 180
 181 add_task(async function do_test_http2_push2() {
 182   const { httpProxyConnectResponseCode } = await test_http2_push2(
 183     loadGroup,
 184     serverPort
 185   );
 186   Assert.equal(httpProxyConnectResponseCode, -1);
 187 });
 188
 189 add_task(async function do_test_http2_push3() {
 190   const { httpProxyConnectResponseCode } = await test_http2_push3(
 191     loadGroup,
 192     serverPort
 193   );
 194   Assert.equal(httpProxyConnectResponseCode, -1);
 195 });
 196
 197 add_task(async function do_test_http2_push4() {
 198   const { httpProxyConnectResponseCode } = await test_http2_push4(
 199     loadGroup,
 200     serverPort
 201   );
 202   Assert.equal(httpProxyConnectResponseCode, -1);
 203 });
 204
 205 add_task(async function do_test_http2_push5() {
 206   const { httpProxyConnectResponseCode } = await test_http2_push5(
 207     loadGroup,
 208     serverPort
 209   );
 210   Assert.equal(httpProxyConnectResponseCode, -1);
 211 });
 212
 213 add_task(async function do_test_http2_push6() {
 214   const { httpProxyConnectResponseCode } = await test_http2_push6(
 215     loadGroup,
 216     serverPort
 217   );
 218   Assert.equal(httpProxyConnectResponseCode, -1);
 219 });
 220
 221 add_task(async function do_test_http2_altsvc() {
 222   const { httpProxyConnectResponseCode } = await test_http2_altsvc(
 223     httpserv.identity.primaryPort,
 224     httpserv2.identity.primaryPort,
 225     false
 226   );
 227   Assert.equal(httpProxyConnectResponseCode, -1);
 228 });
 229
 230 add_task(async function do_test_http2_doubleheader() {
 231   const { httpProxyConnectResponseCode } =
 232     await test_http2_doubleheader(serverPort);
 233   Assert.equal(httpProxyConnectResponseCode, -1);
 234 });
 235
 236 add_task(async function do_test_http2_xhr() {
 237   await test_http2_xhr(serverPort);
 238 });
 239
 240 add_task(async function do_test_http2_header() {
 241   const { httpProxyConnectResponseCode } = await test_http2_header(serverPort);
 242   Assert.equal(httpProxyConnectResponseCode, -1);
 243 });
 244
 245 add_task(async function do_test_http2_invalid_response_header_name_spaces() {
 246   const { httpProxyConnectResponseCode } =
 247     await test_http2_invalid_response_header(serverPort, "name_spaces");
 248   Assert.equal(httpProxyConnectResponseCode, -1);
 249 });
 250
 251 add_task(
 252   async function do_test_http2_invalid_response_header_value_line_feed() {
 253     const { httpProxyConnectResponseCode } =
 254       await test_http2_invalid_response_header(serverPort, "value_line_feed");
 255     Assert.equal(httpProxyConnectResponseCode, -1);
 256   }
 257 );
 258
 259 add_task(
 260   async function do_test_http2_invalid_response_header_value_carriage_return() {
 261     const { httpProxyConnectResponseCode } =
 262       await test_http2_invalid_response_header(
 263         serverPort,
 264         "value_carriage_return"
 265       );
 266     Assert.equal(httpProxyConnectResponseCode, -1);
 267   }
 268 );
 269
 270 add_task(async function do_test_http2_invalid_response_header_value_null() {
 271   const { httpProxyConnectResponseCode } =
 272     await test_http2_invalid_response_header(serverPort, "value_null");
 273   Assert.equal(httpProxyConnectResponseCode, -1);
 274 });
 275
 276 add_task(async function do_test_http2_cookie_crumbling() {
 277   const { httpProxyConnectResponseCode } =
 278     await test_http2_cookie_crumbling(serverPort);
 279   Assert.equal(httpProxyConnectResponseCode, -1);
 280 });
 281
 282 add_task(async function do_test_http2_multiplex() {
 283   var values = await test_http2_multiplex(serverPort);
 284   Assert.equal(values[0].httpProxyConnectResponseCode, -1);
 285   Assert.equal(values[1].httpProxyConnectResponseCode, -1);
 286   Assert.notEqual(values[0].streamID, values[1].streamID);
 287 });
 288
 289 add_task(async function do_test_http2_big() {
 290   const { httpProxyConnectResponseCode } = await test_http2_big(serverPort);
 291   Assert.equal(httpProxyConnectResponseCode, -1);
 292 });
 293
 294 add_task(async function do_test_http2_huge_suspended() {
 295   const { httpProxyConnectResponseCode } =
 296     await test_http2_huge_suspended(serverPort);
 297   Assert.equal(httpProxyConnectResponseCode, -1);
 298 });
 299
 300 add_task(async function do_test_http2_post() {
 301   const { httpProxyConnectResponseCode } = await test_http2_post(serverPort);
 302   Assert.equal(httpProxyConnectResponseCode, -1);
 303 });
 304
 305 add_task(async function do_test_http2_empty_post() {
 306   const { httpProxyConnectResponseCode } =
 307     await test_http2_empty_post(serverPort);
 308   Assert.equal(httpProxyConnectResponseCode, -1);
 309 });
 310
 311 add_task(async function do_test_http2_patch() {
 312   const { httpProxyConnectResponseCode } = await test_http2_patch(serverPort);
 313   Assert.equal(httpProxyConnectResponseCode, -1);
 314 });
 315
 316 add_task(async function do_test_http2_pushapi_1() {
 317   const { httpProxyConnectResponseCode } = await test_http2_pushapi_1(
 318     loadGroup,
 319     serverPort
 320   );
 321   Assert.equal(httpProxyConnectResponseCode, -1);
 322 });
 323
 324 add_task(async function do_test_http2_continuations() {
 325   const { httpProxyConnectResponseCode } = await test_http2_continuations(
 326     loadGroup,
 327     serverPort
 328   );
 329   Assert.equal(httpProxyConnectResponseCode, -1);
 330 });
 331
 332 add_task(async function do_test_http2_blocking_download() {
 333   const { httpProxyConnectResponseCode } =
 334     await test_http2_blocking_download(serverPort);
 335   Assert.equal(httpProxyConnectResponseCode, -1);
 336 });
 337
 338 add_task(async function do_test_http2_illegalhpacksoft() {
 339   const { httpProxyConnectResponseCode } =
 340     await test_http2_illegalhpacksoft(serverPort);
 341   Assert.equal(httpProxyConnectResponseCode, -1);
 342 });
 343
 344 add_task(async function do_test_http2_illegalhpackhard() {
 345   const { httpProxyConnectResponseCode } =
 346     await test_http2_illegalhpackhard(serverPort);
 347   Assert.equal(httpProxyConnectResponseCode, -1);
 348 });
 349
 350 add_task(async function do_test_http2_folded_header() {
 351   const { httpProxyConnectResponseCode } = await test_http2_folded_header(
 352     loadGroup,
 353     serverPort
 354   );
 355   Assert.equal(httpProxyConnectResponseCode, -1);
 356 });
 357
 358 add_task(async function do_test_http2_empty_data() {
 359   const { httpProxyConnectResponseCode } =
 360     await test_http2_empty_data(serverPort);
 361   Assert.equal(httpProxyConnectResponseCode, -1);
 362 });
 363
 364 add_task(async function do_test_http2_status_phrase() {
 365   const { httpProxyConnectResponseCode } =
 366     await test_http2_status_phrase(serverPort);
 367   Assert.equal(httpProxyConnectResponseCode, -1);
 368 });
 369
 370 add_task(async function do_test_http2_doublepush() {
 371   const { httpProxyConnectResponseCode } = await test_http2_doublepush(
 372     loadGroup,
 373     serverPort
 374   );
 375   Assert.equal(httpProxyConnectResponseCode, -1);
 376 });
 377
 378 add_task(async function do_test_http2_disk_cache_push() {
 379   const { httpProxyConnectResponseCode } = await test_http2_disk_cache_push(
 380     loadGroup,
 381     serverPort
 382   );
 383   Assert.equal(httpProxyConnectResponseCode, -1);
 384 });
 385
 386 add_task(async function do_test_http2_h11required_stream() {
 387   // Add new tests above here - best to add new tests before h1
 388   // streams get too involved
 389   // These next two must always come in this order
 390   const { httpProxyConnectResponseCode } =
 391     await test_http2_h11required_stream(serverPort);
 392   Assert.equal(httpProxyConnectResponseCode, -1);
 393 });
 394
 395 add_task(async function do_test_http2_h11required_session() {
 396   const { httpProxyConnectResponseCode } =
 397     await test_http2_h11required_session(serverPort);
 398   Assert.equal(httpProxyConnectResponseCode, -1);
 399 });
 400
 401 add_task(async function do_test_http2_retry_rst() {
 402   const { httpProxyConnectResponseCode } =
 403     await test_http2_retry_rst(serverPort);
 404   Assert.equal(httpProxyConnectResponseCode, -1);
 405 });
 406
 407 add_task(async function do_test_http2_wrongsuite_tls12() {
 408   const { httpProxyConnectResponseCode } =
 409     await test_http2_wrongsuite_tls12(serverPort);
 410   Assert.equal(httpProxyConnectResponseCode, -1);
 411 });
 412
 413 add_task(async function do_test_http2_wrongsuite_tls13() {
 414   const { httpProxyConnectResponseCode } =
 415     await test_http2_wrongsuite_tls13(serverPort);
 416   Assert.equal(httpProxyConnectResponseCode, -1);
 417 });
 418
 419 add_task(async function do_test_http2_push_firstparty1() {
 420   const { httpProxyConnectResponseCode } = await test_http2_push_firstparty1(
 421     loadGroup,
 422     serverPort
 423   );
 424   Assert.equal(httpProxyConnectResponseCode, -1);
 425 });
 426
 427 add_task(async function do_test_http2_push_firstparty2() {
 428   const { httpProxyConnectResponseCode } = await test_http2_push_firstparty2(
 429     loadGroup,
 430     serverPort
 431   );
 432   Assert.equal(httpProxyConnectResponseCode, -1);
 433 });
 434
 435 add_task(async function do_test_http2_push_firstparty3() {
 436   const { httpProxyConnectResponseCode } = await test_http2_push_firstparty3(
 437     loadGroup,
 438     serverPort
 439   );
 440   Assert.equal(httpProxyConnectResponseCode, -1);
 441 });
 442
 443 add_task(async function do_test_http2_push_userContext1() {
 444   const { httpProxyConnectResponseCode } = await test_http2_push_userContext1(
 445     loadGroup,
 446     serverPort
 447   );
 448   Assert.equal(httpProxyConnectResponseCode, -1);
 449 });
 450
 451 add_task(async function do_test_http2_push_userContext2() {
 452   const { httpProxyConnectResponseCode } = await test_http2_push_userContext2(
 453     loadGroup,
 454     serverPort
 455   );
 456   Assert.equal(httpProxyConnectResponseCode, -1);
 457 });
 458
 459 add_task(async function do_test_http2_push_userContext3() {
 460   const { httpProxyConnectResponseCode } = await test_http2_push_userContext3(
 461     loadGroup,
 462     serverPort
 463   );
 464   Assert.equal(httpProxyConnectResponseCode, -1);
 465 });
 466
 467 add_task(async function do_test_http2_continuations_over_max_response_limit() {
 468   const { httpProxyConnectResponseCode } =
 469     await test_http2_continuations_over_max_response_limit(
 470       loadGroup,
 471       serverPort
 472     );
 473   Assert.equal(httpProxyConnectResponseCode, -1);
 474 });