Index: frontend/node_modules/spdy/test/client-test.js
===================================================================
--- frontend/node_modules/spdy/test/client-test.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/spdy/test/client-test.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,242 @@
+/* eslint-env mocha */
+
+var assert = require('assert')
+var https = require('https')
+var http = require('http')
+var util = require('util')
+
+var fixtures = require('./fixtures')
+var spdy = require('../')
+
+// Node.js 0.10 and 0.12 support
+Object.assign = process.versions.modules >= 46
+  ? Object.assign // eslint-disable-next-line
+  : util._extend
+
+describe('SPDY Client', function () {
+  describe('regular', function () {
+    fixtures.everyConfig(function (protocol, alpn, version, plain) {
+      var server
+      var agent
+      var hmodule
+
+      beforeEach(function (done) {
+        hmodule = plain ? http : https
+
+        var options = Object.assign({
+          spdy: {
+            plain: plain
+          }
+        }, fixtures.keys)
+        server = spdy.createServer(options, function (req, res) {
+          var body = ''
+          req.on('data', function (chunk) {
+            body += chunk
+          })
+          req.on('end', function () {
+            res.writeHead(200, req.headers)
+            res.addTrailers({ trai: 'ler' })
+
+            var push = res.push('/push', {
+              request: {
+                push: 'yes'
+              }
+            }, function (err) {
+              assert(!err)
+
+              push.end('push')
+              push.on('error', function () {
+              })
+
+              res.end(body || 'okay')
+            })
+          })
+        })
+
+        server.listen(fixtures.port, function () {
+          agent = spdy.createAgent({
+            rejectUnauthorized: false,
+            port: fixtures.port,
+            spdy: {
+              plain: plain,
+              protocol: plain ? alpn : null,
+              protocols: [alpn]
+            }
+          })
+
+          done()
+        })
+      })
+
+      afterEach(function (done) {
+        var waiting = 2
+        agent.close(next)
+        server.close(next)
+
+        function next () {
+          if (--waiting === 0) {
+            done()
+          }
+        }
+      })
+
+      it('should send GET request', function (done) {
+        var req = hmodule.request({
+          agent: agent,
+
+          method: 'GET',
+          path: '/get',
+          headers: {
+            a: 'b'
+          }
+        }, function (res) {
+          assert.strictEqual(res.statusCode, 200)
+          assert.strictEqual(res.headers.a, 'b')
+
+          fixtures.expectData(res, 'okay', done)
+        })
+        req.end()
+      })
+
+      it('should send POST request', function (done) {
+        var req = hmodule.request({
+          agent: agent,
+
+          method: 'POST',
+          path: '/post',
+
+          headers: {
+            post: 'headers'
+          }
+        }, function (res) {
+          assert.strictEqual(res.statusCode, 200)
+          assert.strictEqual(res.headers.post, 'headers')
+
+          fixtures.expectData(res, 'post body', done)
+        })
+
+        agent._spdyState.socket.once(plain ? 'connect' : 'secureConnect',
+          function () {
+            req.end('post body')
+          })
+      })
+
+      it('should receive PUSH_PROMISE', function (done) {
+        var req = hmodule.request({
+          agent: agent,
+
+          method: 'GET',
+          path: '/get'
+        }, function (res) {
+          assert.strictEqual(res.statusCode, 200)
+
+          res.resume()
+        })
+        req.on('push', function (push) {
+          assert.strictEqual(push.path, '/push')
+          assert.strictEqual(push.headers.push, 'yes')
+
+          push.resume()
+          push.once('end', done)
+        })
+        req.end()
+      })
+
+      it('should receive trailing headers', function (done) {
+        var req = hmodule.request({
+          agent: agent,
+
+          method: 'GET',
+          path: '/get'
+        }, function (res) {
+          assert.strictEqual(res.statusCode, 200)
+
+          res.on('trailers', function (headers) {
+            assert.strictEqual(headers.trai, 'ler')
+            fixtures.expectData(res, 'okay', done)
+          })
+        })
+        req.end()
+      })
+    })
+  })
+
+  describe('x-forwarded-for', function () {
+    fixtures.everyConfig(function (protocol, alpn, version, plain) {
+      var server
+      var agent
+      var hmodule
+      // The underlying spdy Connection created by the agent.
+      var connection
+
+      beforeEach(function (done) {
+        hmodule = plain ? http : https
+
+        var options = Object.assign({
+          spdy: {
+            plain: plain,
+            'x-forwarded-for': true
+          }
+        }, fixtures.keys)
+        server = spdy.createServer(options, function (req, res) {
+          res.writeHead(200, req.headers)
+          res.end()
+        })
+
+        server.listen(fixtures.port, function () {
+          agent = spdy.createAgent({
+            rejectUnauthorized: false,
+            port: fixtures.port,
+            spdy: {
+              'x-forwarded-for': '1.2.3.4',
+              plain: plain,
+              protocol: plain ? alpn : null,
+              protocols: [alpn]
+            }
+          })
+          // Once aagent has connection, keep a copy for testing.
+          agent.once('_connect', function () {
+            connection = agent._spdyState.connection
+            done()
+          })
+        })
+      })
+
+      afterEach(function (done) {
+        var waiting = 2
+        agent.close(next)
+        server.close(next)
+
+        function next () {
+          if (--waiting === 0) {
+            done()
+          }
+        }
+      })
+
+      it('should send x-forwarded-for', function (done) {
+        var req = hmodule.request({
+          agent: agent,
+
+          method: 'GET',
+          path: '/get'
+        }, function (res) {
+          assert.strictEqual(res.statusCode, 200)
+          assert.strictEqual(res.headers['x-forwarded-for'], '1.2.3.4')
+
+          res.resume()
+          res.once('end', done)
+        })
+        req.end()
+      })
+
+      it('agent should emit connection level errors', function (done) {
+        agent.once('error', function (err) {
+          assert.strictEqual(err.message, 'mock error')
+          done()
+        })
+        connection.emit('error', new Error('mock error'))
+      })
+    })
+  })
+})
Index: frontend/node_modules/spdy/test/fixtures.js
===================================================================
--- frontend/node_modules/spdy/test/fixtures.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/spdy/test/fixtures.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,95 @@
+/* eslint-env mocha */
+'use strict'
+
+var assert = require('assert')
+
+exports.port = 23433
+
+exports.keys = {
+  key: '-----BEGIN RSA PRIVATE KEY-----\n' +
+       'MIIEogIBAAKCAQEA1ARXSoyizYSnHDYickxX4x2UG/8uNWnQWKlWR97NAwRsspN6\n' +
+       'aFF1+LnyN9bvLNnhxIowcYy68+LpZ7pYAQgBZSyAhnF1S4qz2w/rxH4CNn96B/je\n' +
+       'vQGo3e8vIQ8ChhfuYvGAtTEYJzW8aRoxWSPcukZZdxPQ1Wgbhd9DSXhgkUnkEEET\n' +
+       'owyn8ufQFRnQHfc9Fn5DrJilI7vD+ZyRU3gZoBj2GVMQuxJLqQEHy2XsJ6ZWTea/\n' +
+       'EfK93XfDyY7ZxyeK0ZdWCVoTqw9QNJSkGjesCBkcY4Rjxi9LbLJwW3Es4wgW4N4Y\n' +
+       'cltfygjltSis+RVKJyGeDqTWAxceih3mlkdGIQIDAQABAoIBAB6akc8dBdMMtuKH\n' +
+       'nelJw9XwyxRPfWgQYhaqOt4c9xLcbKRKTX0JZTIGBUSyLcwXl1M7b0q0ubfCpVZn\n' +
+       'u5RKh4kHJ3ZAomHJH7UbUzkFx2P+eqrz7ZLyzmFayT7IX+DjS3HU0nNVJttiElRJ\n' +
+       'h54KYy4wQXHC1n43jOGCHMBaM/ZEpO3xA7PLfVD/BpYLzL+FAYoFBb/x2buLv8Mg\n' +
+       'D6QAWkS70mu8ER13NapKjg6PUsYPxHYU30BjGMTXw95Iz5PSAK8+/xQ6YaW7MEVM\n' +
+       'twxxfJfZ+9u9nJMfJANqxCi6iZ6ft/e5cbhvNhV/X97XeoPWxqSpx98M6BC/vvBc\n' +
+       'UjSmaRECgYEA4NH8Y20zC8zF4ALcBgqgrx+U9upov2UGa+kjS1/So4r/dpG4T8pT\n' +
+       'T2tMW6zR5qe7g11kgJm0oI/I6x9P2qwFJONO3MdLYVKd2mSxG2fniCktLg2j6BAX\n' +
+       'QTt5zjIEWvhRP2vkrS8gAaJbVMLTMg4s374bE/IdKT+c59tYpcVaXXMCgYEA8WvJ\n' +
+       'dfPXoagEgaHRd++R2COMG19euOTFRle0MSq+S9ZeeSe9ejb9CIpWYZ3WVviKvf+E\n' +
+       'zksmKTZJnig5pGEgU+2ka1C9PthCGlTlQagD6Ey4hblQgi+pOFgBjE9Yn3FxfppH\n' +
+       '25ICXNY89EF6klEqKV67E/5O+nBZo+Y2TM4YKRsCgYAaEV8RbEUB9kFvYwV+Eddl\n' +
+       '1uSf6LgykRU4h/TWtYqn+eL7LZRQdCZKzCczbgt8kjBU4AxaOPhPsbxbPus0cMO7\n' +
+       '7jtjsBwWcczp2MkMY3TePeAGOgCqVMtNfgb2mKgWoDpTf0ApsJAmgFvUrS5t3GTp\n' +
+       'oJJlMqqc8MpRvAZAWmzK7wKBgEVBFlmvyXumJyTItr4hC0VlbRutEA8aET1Mi3RP\n' +
+       'Pqeipxc6PzB/9bYtePonvQTV53b5ha9n/1pzKEsmXuK4uf1ZfoEKeD8+6jeDgwCC\n' +
+       'ohxRZd12e5Hc+j4fgNIvMM0MTfJzb4mdKPBYxMOMxQyUG/QiKKhjm2RcNlq9/3Wo\n' +
+       '6WVhAoGAG4QPWoE4ccFECp8eyGw8rjE45y5uqUI/f/RssX7bnKbCRY0otDsPlJd6\n' +
+       'Kf0XFssLnYsCXO+ua03gw2N+2mrcsuA5FXHmQMrbfnuojHIVY05nt4Wa5iqV/gqH\n' +
+       'PJXWyOgD+Kd6eR/cih/SCoKl4tSGCSJG5TDEpMt+r8EJkCXJ7Fw=\n' +
+       '-----END RSA PRIVATE KEY-----',
+  cert: '-----BEGIN CERTIFICATE-----\n' +
+        'MIICuTCCAaOgAwIBAgIDAQABMAsGCSqGSIb3DQEBCzAUMRIwEAYDVQQDFglub2Rl\n' +
+        'LnNwZHkwHhcNNjkwMTAxMDAwMDAwWhcNMjUwNzA2MDUwMzQzWjAUMRIwEAYDVQQD\n' +
+        'Fglub2RlLnNwZHkwggEgMAsGCSqGSIb3DQEBAQOCAQ8AMIIBCgKCAQEA1ARXSoyi\n' +
+        'zYSnHDYickxX4x2UG/8uNWnQWKlWR97NAwRsspN6aFF1+LnyN9bvLNnhxIowcYy6\n' +
+        '8+LpZ7pYAQgBZSyAhnF1S4qz2w/rxH4CNn96B/jevQGo3e8vIQ8ChhfuYvGAtTEY\n' +
+        'JzW8aRoxWSPcukZZdxPQ1Wgbhd9DSXhgkUnkEEETowyn8ufQFRnQHfc9Fn5DrJil\n' +
+        'I7vD+ZyRU3gZoBj2GVMQuxJLqQEHy2XsJ6ZWTea/EfK93XfDyY7ZxyeK0ZdWCVoT\n' +
+        'qw9QNJSkGjesCBkcY4Rjxi9LbLJwW3Es4wgW4N4YcltfygjltSis+RVKJyGeDqTW\n' +
+        'Axceih3mlkdGIQIDAQABoxowGDAWBgNVHREEDzANggsqLm5vZGUuc3BkeTALBgkq\n' +
+        'hkiG9w0BAQsDggEBALn2FQSDMsyu+oqUnJgTVdGpnzKmfXoBPlQuznRdibri8ABO\n' +
+        'kOo8FC72Iy6leVSsB26KtAdhpURZ3mv1Oyt4cGeeyQln2Olzp5flIos+GqYSztAq\n' +
+        '5ZnrzTLLlip7KHkmastYRXhEwTLmo2JCU8RkRP1X/m1xONF/YkURxmqj6cQTahPY\n' +
+        'FzzLP1clW3arJwPlUcKKby6WpxO5MihYEliheBr7fL2TDUA96eG+B/SKxvwaGF2v\n' +
+        'gWF8rg5prjPaLW8HH3Efq59AimFqUVQ4HtcJApjLJDYUKlvsMNMvBqh/pQRRPafj\n' +
+        '0Cp8dyS45sbZ2RgXdyfl6gNEj+DiPbaFliIuFmM=\n' +
+        '-----END CERTIFICATE-----'
+}
+
+function expectData (stream, expected, callback) {
+  var actual = ''
+
+  stream.on('data', function (chunk) {
+    actual += chunk
+  })
+  stream.on('end', function () {
+    assert.strictEqual(actual, expected)
+    callback()
+  })
+}
+exports.expectData = expectData
+
+exports.everyProtocol = function everyProtocol (body) {
+  var protocols = [
+    { protocol: 'http2', alpn: 'h2', version: 4 },
+    { protocol: 'spdy', alpn: 'spdy/3.1', version: 3.1 },
+    { protocol: 'spdy', alpn: 'spdy/3', version: 3 },
+    { protocol: 'spdy', alpn: 'spdy/2', version: 2 }
+  ]
+
+  protocols.forEach(function (protocol) {
+    describe(protocol.alpn, function () {
+      body(protocol.protocol, protocol.alpn, protocol.version)
+    })
+  })
+}
+
+exports.everyConfig = function everyConfig (body) {
+  exports.everyProtocol(function (protocol, alpn, version) {
+    if (alpn === 'spdy/2') {
+      return
+    }
+
+    [false, true].forEach(function (plain) {
+      describe(plain ? 'plain mode' : 'ssl mode', function () {
+        body(protocol, alpn, version, plain)
+      })
+    })
+  })
+}
Index: frontend/node_modules/spdy/test/server-test.js
===================================================================
--- frontend/node_modules/spdy/test/server-test.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/spdy/test/server-test.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,487 @@
+/* eslint-env mocha */
+
+var assert = require('assert')
+var tls = require('tls')
+var net = require('net')
+var https = require('https')
+var transport = require('spdy-transport')
+var util = require('util')
+
+var fixtures = require('./fixtures')
+var spdy = require('../')
+
+describe('SPDY Server', function () {
+  fixtures.everyConfig(function (protocol, alpn, version, plain) {
+    var server
+    var client
+
+    beforeEach(function (done) {
+      server = spdy.createServer(Object.assign({
+        spdy: {
+          'x-forwarded-for': true,
+          plain: plain
+        }
+      }, fixtures.keys))
+
+      server.listen(fixtures.port, function () {
+        var socket = (plain ? net : tls).connect({
+          rejectUnauthorized: false,
+          port: fixtures.port,
+          ALPNProtocols: [alpn]
+        }, function () {
+          client = transport.connection.create(socket, {
+            protocol: protocol,
+            isServer: false
+          })
+          client.start(version)
+          done()
+        })
+      })
+    })
+
+    afterEach(function (done) {
+      client.socket.destroy()
+      server.close(done)
+    })
+
+    it('should process GET request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          a: 'b'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('error', (err) => {
+          done(err)
+        })
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.isSpdy, res.isSpdy)
+        assert.strictEqual(req.spdyVersion, res.spdyVersion)
+        assert(req.isSpdy)
+        if (!plain) {
+          assert(req.socket.encrypted)
+          assert(req.socket.getPeerCertificate())
+        }
+
+        // Auto-detection
+        if (version === 3.1) {
+          assert(req.spdyVersion >= 3 && req.spdyVersion <= 3.1)
+        } else {
+          assert.strictEqual(req.spdyVersion, version)
+        }
+        assert(req.spdyStream)
+        assert(res.spdyStream)
+
+        assert.strictEqual(req.method, 'GET')
+        assert.strictEqual(req.url, '/get')
+        assert.deepStrictEqual(req.headers, { a: 'b', host: 'localhost' })
+
+        req.on('end', function () {
+          res.writeHead(200, {
+            ok: 'yes'
+          })
+          res.end('response')
+          assert(res.finished, 'res.finished should be set')
+        })
+        req.resume()
+      })
+    })
+
+    it('should process POST request', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', next)
+        })
+
+        stream.end('request')
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.method, 'POST')
+        assert.strictEqual(req.url, '/post')
+
+        res.writeHead(200, {
+          ok: 'yes'
+        })
+        res.end('response')
+
+        fixtures.expectData(req, 'request', next)
+      })
+
+      var waiting = 2
+      function next () {
+        if (--waiting === 0) {
+          return done()
+        }
+      }
+    })
+
+    it('should process expect-continue request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          Expect: '100-continue'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 100)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.on('end', function () {
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should emit `checkContinue` request', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/get',
+        headers: {
+          Expect: '100-continue'
+        }
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 100)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('checkContinue', function (req, res) {
+        req.on('end', function () {
+          res.writeContinue()
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should send PUSH_PROMISE', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/page'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('pushPromise', function (push) {
+          assert.strictEqual(push.path, '/push')
+          assert.strictEqual(push.headers.yes, 'push')
+
+          fixtures.expectData(push, 'push', next)
+          fixtures.expectData(stream, 'response', next)
+        })
+
+        stream.end('request')
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.method, 'POST')
+        assert.strictEqual(req.url, '/page')
+
+        res.writeHead(200, {
+          ok: 'yes'
+        })
+
+        var push = res.push('/push', {
+          request: {
+            yes: 'push'
+          }
+        })
+        push.end('push')
+
+        res.end('response')
+
+        fixtures.expectData(req, 'request', next)
+      })
+
+      var waiting = 3
+      function next () {
+        if (--waiting === 0) {
+          return done()
+        }
+      }
+    })
+
+    it('should receive trailing headers', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.sendHeaders({ trai: 'ler' })
+        stream.end()
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+          assert.strictEqual(headers.ok, 'yes')
+
+          fixtures.expectData(stream, 'response', done)
+        })
+      })
+
+      server.on('request', function (req, res) {
+        var gotHeaders = false
+        req.on('trailers', function (headers) {
+          gotHeaders = true
+          assert.strictEqual(headers.trai, 'ler')
+        })
+
+        req.on('end', function () {
+          assert(gotHeaders)
+
+          res.writeHead(200, {
+            ok: 'yes'
+          })
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should call .writeHead() automatically', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 300)
+
+          fixtures.expectData(stream, 'response', done)
+        })
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.on('end', function () {
+          res.statusCode = 300
+          res.end('response')
+        })
+        req.resume()
+      })
+    })
+
+    it('should not crash on .writeHead() after socket close', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        setTimeout(function () {
+          client.socket.destroy()
+        }, 50)
+        stream.on('error', function () {})
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.connection.on('close', function () {
+          assert.doesNotThrow(function () {
+            res.writeHead(200)
+            res.end('response')
+          })
+          done()
+        })
+      })
+    })
+
+    it('should not crash on .push() after socket close', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        setTimeout(function () {
+          client.socket.destroy()
+        }, 50)
+        stream.on('error', function () {})
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.connection.on('close', function () {
+          assert.doesNotThrow(function () {
+            assert.strictEqual(res.push('/push', {}), undefined)
+            res.end('response')
+          })
+          done()
+        })
+      })
+    })
+
+    it('should end response after writing everything down', function (done) {
+      var stream = client.request({
+        method: 'GET',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.on('response', function (status, headers) {
+          assert.strictEqual(status, 200)
+
+          fixtures.expectData(stream, 'hello world, what\'s up?', done)
+        })
+
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        req.resume()
+        res.writeHead(200)
+        res.write('hello ')
+        res.write('world')
+        res.write(', what\'s')
+        res.write(' up?')
+        res.end()
+      })
+    })
+
+    it('should handle x-forwarded-for', function (done) {
+      client.sendXForwardedFor('1.2.3.4')
+
+      var stream = client.request({
+        method: 'GET',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+
+        stream.resume()
+        stream.on('end', done)
+        stream.end()
+      })
+
+      server.on('request', function (req, res) {
+        assert.strictEqual(req.headers['x-forwarded-for'], '1.2.3.4')
+        req.resume()
+        res.end()
+      })
+    })
+
+    it('should destroy request after end', function (done) {
+      var stream = client.request({
+        method: 'POST',
+        path: '/post'
+      }, function (err) {
+        assert(!err)
+      })
+      stream.end()
+      stream.on('error', function () {})
+
+      server.on('request', function (req, res) {
+        res.end()
+        res.destroy()
+        res.socket.on('close', function () {
+          done()
+        })
+      })
+    })
+  })
+
+  it('should respond to http/1.1', function (done) {
+    var server = spdy.createServer(fixtures.keys, function (req, res) {
+      assert.strictEqual(req.isSpdy, res.isSpdy)
+      assert.strictEqual(req.spdyVersion, res.spdyVersion)
+      assert(!req.isSpdy)
+      assert.strictEqual(req.spdyVersion, 1)
+
+      res.writeHead(200)
+      res.end()
+    })
+
+    server.listen(fixtures.port, function () {
+      var req = https.request({
+        agent: false,
+        rejectUnauthorized: false,
+        NPNProtocols: ['http/1.1'],
+        port: fixtures.port,
+        method: 'GET',
+        path: '/'
+      }, function (res) {
+        assert.strictEqual(res.statusCode, 200)
+        res.resume()
+        res.on('end', function () {
+          server.close(done)
+        })
+      })
+
+      req.end()
+    })
+  })
+
+  it('should support custom base', function (done) {
+    function Pseuver (options, listener) {
+      https.Server.call(this, options, listener)
+    }
+    util.inherits(Pseuver, https.Server)
+
+    var server = spdy.createServer(Pseuver, fixtures.keys, function (req, res) {
+      assert.strictEqual(req.isSpdy, res.isSpdy)
+      assert.strictEqual(req.spdyVersion, res.spdyVersion)
+      assert(!req.isSpdy)
+      assert.strictEqual(req.spdyVersion, 1)
+
+      res.writeHead(200)
+      res.end()
+    })
+
+    server.listen(fixtures.port, function () {
+      var req = https.request({
+        agent: false,
+        rejectUnauthorized: false,
+        NPNProtocols: ['http/1.1'],
+        port: fixtures.port,
+        method: 'GET',
+        path: '/'
+      }, function (res) {
+        assert.strictEqual(res.statusCode, 200)
+        res.resume()
+        res.on('end', function () {
+          server.close(done)
+        })
+      })
+
+      req.end()
+    })
+  })
+})