netwerk/test/unit/test_verify_traffic.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 "use strict";
   6
   7 /* import-globals-from head_cache.js */
   8 /* import-globals-from head_cookies.js */
   9 /* import-globals-from head_channels.js */
  10 /* import-globals-from head_servers.js */
  11
  12 const gDashboard = Cc["@mozilla.org/network/dashboard;1"].getService(
  13   Ci.nsIDashboard
  14 );
  15
  16 const { TestUtils } = ChromeUtils.importESModule(
  17   "resource://testing-common/TestUtils.sys.mjs"
  18 );
  19
  20 function makeChan(uri) {
  21   let chan = NetUtil.newChannel({
  22     uri,
  23     loadUsingSystemPrincipal: true,
  24   }).QueryInterface(Ci.nsIHttpChannel);
  25   chan.loadFlags = Ci.nsIChannel.LOAD_INITIAL_DOCUMENT_URI;
  26   return chan;
  27 }
  28
  29 function channelOpenPromise(chan, flags) {
  30   return new Promise(resolve => {
  31     function finish(req, buffer) {
  32       resolve([req, buffer]);
  33     }
  34     chan.asyncOpen(new ChannelListener(finish, null, flags));
  35   });
  36 }
  37
  38 async function registerSimplePathHandler(server, path) {
  39   return server.registerPathHandler(path, (req, resp) => {
  40     resp.writeHead(200);
  41     resp.end("done");
  42   });
  43 }
  44
  45 add_task(async function test_verify_traffic_for_http2() {
  46   Services.prefs.setBoolPref(
  47     "network.http.http2.move_to_pending_list_after_network_change",
  48     true
  49   );
  50
  51   // Bug 1878505: It seems when HTTPS RR is enabled, a speculative
  52   // connection that waits to receive a HTTPS response will receive it
  53   // after the actual connection is established, leading to an extra
  54   // connection being established.
  55   Services.prefs.setIntPref("network.http.speculative-parallel-limit", 0);
  56
  57   let certdb = Cc["@mozilla.org/security/x509certdb;1"].getService(
  58     Ci.nsIX509CertDB
  59   );
  60   addCertFromFile(certdb, "http2-ca.pem", "CTu,u,u");
  61
  62   let server = new NodeHTTP2Server();
  63   await server.start();
  64   registerCleanupFunction(async () => {
  65     Services.prefs.clearUserPref(
  66       "network.http.http2.move_to_pending_list_after_network_change"
  67     );
  68     await server.stop();
  69   });
  70
  71   try {
  72     await server.registerPathHandler("/longDelay", (req, resp) => {
  73       // eslint-disable-next-line mozilla/no-arbitrary-setTimeout, no-undef
  74       setTimeout(function () {
  75         resp.writeHead(200);
  76         resp.end("done");
  77       }, 8000);
  78     });
  79   } catch (e) {}
  80
  81   await registerSimplePathHandler(server, "/test");
  82
  83   // Send some requests and check if we have only one h2 session.
  84   for (let i = 0; i < 2; i++) {
  85     let chan = makeChan(`https://localhost:${server.port()}/test`);
  86     await channelOpenPromise(chan, CL_ALLOW_UNKNOWN_CL);
  87   }
  88   let sessionCount = await server.sessionCount();
  89   Assert.equal(sessionCount, 1);
  90
  91   let res = await new Promise(resolve => {
  92     // Create a request that takes 8s to finish.
  93     let chan = makeChan(`https://localhost:${server.port()}/longDelay`);
  94     chan.asyncOpen(new ChannelListener(resolve, null, CL_ALLOW_UNKNOWN_CL));
  95
  96     // Send a network change event to trigger VerifyTraffic(). After this,
  97     // the connnection will be put in the pending list.
  98     // We'll crate a new connection for the new request.
  99     Services.obs.notifyObservers(
 100       null,
 101       "network:link-status-changed",
 102       "changed"
 103     );
 104
 105     // This request will use the new connection.
 106     let chan1 = makeChan(`https://localhost:${server.port()}/test`);
 107     chan1.asyncOpen(new ChannelListener(() => {}, null, CL_ALLOW_UNKNOWN_CL));
 108   });
 109
 110   // The connection in the pending list should be still working.
 111   Assert.equal(res.status, Cr.NS_OK);
 112   Assert.equal(res.QueryInterface(Ci.nsIHttpChannel).responseStatus, 200);
 113
 114   sessionCount = await server.sessionCount();
 115   Assert.equal(sessionCount, 2);
 116
 117   // Create another request and trigger the network change event again.
 118   // The second network change event is to put the second connection into the
 119   // pending list.
 120   res = await new Promise(resolve => {
 121     // Create a request that takes 8s to finish.
 122     let chan = makeChan(`https://localhost:${server.port()}/longDelay`);
 123     chan.asyncOpen(new ChannelListener(resolve, null, CL_ALLOW_UNKNOWN_CL));
 124
 125     Services.obs.notifyObservers(
 126       null,
 127       "network:link-status-changed",
 128       "changed"
 129     );
 130   });
 131
 132   Assert.equal(res.status, Cr.NS_OK);
 133   Assert.equal(res.QueryInterface(Ci.nsIHttpChannel).responseStatus, 200);
 134
 135   async function getSocketCount() {
 136     return new Promise(resolve => {
 137       gDashboard.requestSockets(function (data) {
 138         resolve(data.sockets.length);
 139       });
 140     });
 141   }
 142
 143   await TestUtils.waitForCondition(async () => {
 144     const socketCount = await getSocketCount();
 145     return socketCount === 0;
 146   }, "Socket count should be 0");
 147
 148   await server.stop();
 149 });