[test] http2 options

Author: kinetifex

test/create-servers-test.js

@@ -10,6 +10,7 @@ var path = require('path'),
   url = require('url'),
   http = require('http'),
   https = require('https'),
+  http2 = require('http2'),
   { promisify } = require('util'),
   test = require('tape'),
   sinon = require('sinon'),
@@ -18,6 +19,8 @@ var path = require('path'),
 
 const createServersAsync = promisify(createServers);
 
+const { HTTP2_HEADER_PATH } = http2.constants;
+
 const ca = fs.readFileSync(path.join(__dirname, './fixtures/example-ca-cert.pem'));
 
 //
@@ -50,6 +53,74 @@ async function download(httpsURL) {
   });
 }
 
+//
+// Request and download response from a URL using HTTP/2
+//
+async function download2(httpsURL) {
+  return new Promise((resolve, reject) => {
+    const clientSession = http2.connect(httpsURL);
+    const fail = results => {
+      clientSession.close();
+      reject(results);
+    };
+
+    const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
+    req.on('response', () => {
+      const chunks = [];
+      req
+        .on('data', chunk => chunks.push(chunk))
+        .once('end', () => {
+          resolve(chunks.map(chunk => chunk.toString('utf8')).join(''));
+          clientSession.close();
+        });
+    })
+      .once('aborted', fail)
+      .once('close', fail)
+      .once('error', fail);
+  });
+}
+
+/**
+ * Helper to start a server with HTTP/2 support.
+ * Returns stop function to handle server and dns cleanup after tests.
+ *
+ * Tests requests can be made to foo.example.org:3456
+ *
+ * @param {object} options - Additional http2 server options.
+ * @returns {Promise<(function(): void)|*>} callback
+ */
+async function startHttp2Server(options = {}) {
+  // disabling to avoid UNABLE_TO_VERIFY_LEAF_SIGNATURE for tests
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+  const servers = await createServersAsync({
+    http2: {
+      port: 3456,
+      root: path.join(__dirname, 'fixtures'),
+      key: 'example-org-key.pem',
+      cert: 'example-org-cert.pem',
+      ...options
+    },
+    handler: (req, res) => {
+      const { httpVersion } = req;
+      const { socket: { alpnProtocol } } = httpVersion === '2.0' ? req.stream.session : req;
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({
+        alpnProtocol,
+        httpVersion
+      }));
+    }
+  });
+
+  evilDNS.add('foo.example.org', '0.0.0.0');
+
+  return function stop() {
+    servers && servers.http2 && servers.http2.close();
+    evilDNS.clear();
+    delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+  };
+}
+
 test('only http', function (t) {
   t.plan(5);
   createServers({
@@ -145,6 +216,28 @@ test('only https', function (t) {
   });
 });
 
+test('only http2', function (t) {
+  t.plan(4);
+  var time = 4000000;
+  createServers({
+    log: console.log,
+    http2: {
+      timeout: time,
+      port: 3456,
+      root: path.join(__dirname, 'fixtures'),
+      key: 'example-org-key.pem',
+      cert: 'example-org-cert.pem'
+    },
+    handler: fend
+  }, function (err, servers) {
+    t.error(err);
+    t.equals(typeof servers, 'object');
+    t.equals(typeof servers.http2, 'object');
+    t.equals(servers.http2.timeout, time);
+    servers.http2.close();
+  });
+});
+
 test('absolute cert path resolution', function (t) {
   t.plan(3);
   createServers({
@@ -445,6 +538,50 @@ test('multiple https servers', async function (t) {
   }
 });
 
+test('supports http2-only requests', async function (t) {
+  t.plan(2);
+  const url = 'https://foo.example.org:3456/';
+
+  let stopServer;
+  try {
+    stopServer = await startHttp2Server({});
+
+    const httpsResponse = await download(url);
+    t.ok(httpsResponse.includes('Unknown ALPN Protocol'));
+
+    const response = JSON.parse(await download2(url));
+    t.equals(response.httpVersion, '2.0');
+
+  } catch (err) {
+    t.error(err);
+  } finally {
+    stopServer && stopServer();
+  }
+});
+
+test('supports http2 and https requests', async function (t) {
+  t.plan(2);
+  const url = 'https://foo.example.org:3456/';
+
+  let stopServer;
+  try {
+    stopServer = await startHttp2Server({
+      allowHTTP1: true
+    });
+
+    const httpsResponse = JSON.parse(await download(url));
+    t.equals(httpsResponse.httpVersion, '1.1');
+
+    const response = JSON.parse(await download2(url));
+    t.equals(response.httpVersion, '2.0');
+
+  } catch (err) {
+    t.error(err);
+  } finally {
+    stopServer && stopServer();
+  }
+});
+
 async function testSni(t, sniConfig, hostNames) {
   t.plan(1);