Additional test cases

Author: jasnell

lib/internal/http2/core.js

@@ -876,6 +876,8 @@ function onStreamClosed(code) {
 
 function onStreamError(error) {
   const session = this.session;
+  if (session === undefined)
+    process.emit('error', error);
   if (!session.emit('streamError', error, this))
     session.emit('error', error, this);
 }
@@ -1117,6 +1119,8 @@ class ServerHttp2Stream extends Http2Stream {
   }
 
   pushStream(headers, options, callback) {
+    if (this.session === undefined || this.session._state.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
     _unrefActive(this);
     const session = this.session;
     const state = session._state;
@@ -1170,6 +1174,8 @@ class ServerHttp2Stream extends Http2Stream {
   }
 
   respond(headers, options) {
+    if (this.session === undefined || this.session._state.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
     _unrefActive(this);
     const state = this._state;
 
@@ -1226,14 +1232,11 @@ class ServerHttp2Stream extends Http2Stream {
   // a 1xx informational code and it MUST be sent before the request/response
   // headers are sent, or an error will be thrown.
   additionalHeaders(headers) {
-    if (this.id === undefined) {
-      this.once('connect', () => this.additionalHeaders(headers));
-      return;
-    }
+    if (this.session === undefined || this.session._state.destroyed)
+      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
 
-    if (this._state.headersSent) {
+    if (this._state.headersSent)
       throw new errors.Error('ERR_HTTP2_HEADERS_AFTER_RESPOND');
-    }
 
     assertIsObject(headers, 'headers');
     headers = Object.assign(Object.create(null), headers);

test/parallel/test-http2-server-destroy-before-additional.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.session.destroy();
+  assert.throws(() => stream.additionalHeaders({}),
+                common.expectsError({
+                  code: 'ERR_HTTP2_INVALID_SESSION',
+                  message: /^The session has been destroyed$/
+                }));
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustNotCall());
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.destroy();
+  }));
+  req.end();
+
+}));

test/parallel/test-http2-server-destroy-before-push.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.session.destroy();
+  assert.throws(() => stream.pushStream({}, common.mustNotCall()),
+                common.expectsError({
+                  code: 'ERR_HTTP2_INVALID_SESSION',
+                  message: /^The session has been destroyed$/
+                }));
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustNotCall());
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.destroy();
+  }));
+  req.end();
+
+}));

test/parallel/test-http2-server-destroy-before-respond.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.session.destroy();
+  assert.throws(() => stream.respond({}),
+                common.expectsError({
+                  code: 'ERR_HTTP2_INVALID_SESSION',
+                  message: /^The session has been destroyed$/
+                }));
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustNotCall());
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.destroy();
+  }));
+  req.end();
+
+}));

test/parallel/test-http2-server-destroy-before-write.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.session.destroy();
+  assert.throws(() => stream.write('data'),
+                common.expectsError({
+                  type: Error,
+                  message: /^write after end$/
+                }));
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustNotCall());
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+    client.destroy();
+  }));
+  req.end();
+
+}));

test/parallel/test-http2-server-rst-before-respond.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.rstWithCancel();
+  stream.additionalHeaders({
+    ':status': 123,
+    abc: 123
+  });
+  setImmediate(() => {
+    stream.respond({':status': 200});
+    stream.end('data');
+  });
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('headers', common.mustNotCall());
+
+  req.on('streamClosed', common.mustCall((code) => {
+    assert.strictEqual(h2.constants.NGHTTP2_CANCEL, code);
+    server.close();
+    client.destroy();
+  }));
+
+  req.on('response', common.mustNotCall());
+
+}));

test/parallel/test-http2-server-shutdown-before-respond.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const common = require('../common');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+// we use the lower-level API here
+server.on('stream', common.mustCall(onStream));
+
+function onStream(stream, headers, flags) {
+  stream.session.shutdown({graceful: true}, common.mustCall(() => {
+    stream.session.destroy();
+  }));
+  stream.respond({});
+  stream.end('data');
+}
+
+server.listen(0);
+
+server.on('listening', common.mustCall(() => {
+
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+
+  const req = client.request({ ':path': '/' });
+
+  req.on('response', common.mustNotCall());
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    server.close();
+  }));
+  req.end();
+
+}));