test: http2 stream.respond() error checks

PR-URL: https://github.com/nodejs/node/pull/18861
Reviewed-By: James M Snell <jasnell@gmail.com>

test/parallel/test-http2-respond-errors.js

@@ -5,95 +5,81 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 const http2 = require('http2');
-const {
+const { Http2Stream } = process.binding('http2');
-  constants,
-  Http2Stream,
-  nghttp2ErrorString
-} = process.binding('http2');
-const { NghttpError } = require('internal/http2/util');
 
-// tests error handling within respond
+const types = {
-// - every other NGHTTP2 error from binding (should emit stream error)
+  boolean: true,
-
+  function: () => {},
-const specificTestKeys = [];
+  number: 1,
-
+  object: {},
-const specificTests = [];
+  array: [],
-
+  null: null,
-const genericTests = Object.getOwnPropertyNames(constants)
+  symbol: Symbol('test')
-  .filter((key) => (
+};
-    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
-  ))
-  .map((key) => ({
-    ngError: constants[key],
-    error: {
-      code: 'ERR_HTTP2_ERROR',
-      type: NghttpError,
-      name: 'Error [ERR_HTTP2_ERROR]',
-      message: nghttp2ErrorString(constants[key])
-    },
-    type: 'stream'
-  }));
-
-
-const tests = specificTests.concat(genericTests);
-
-let currentError;
-
-// mock submitResponse because we only care about testing error handling
-Http2Stream.prototype.respond = () => currentError.ngError;
 
 const server = http2.createServer();
-server.on('stream', common.mustCall((stream, headers) => {
+
-  const errorMustCall = common.expectsError(currentError.error);
+Http2Stream.prototype.respond = () => 1;
-  const errorMustNotCall = common.mustNotCall(
+server.on('stream', common.mustCall((stream) => {
-    `${currentError.error.code} should emit on ${currentError.type}`
+
+  // Check for all possible TypeError triggers on options.getTrailers
+  Object.entries(types).forEach(([type, value]) => {
+    if (type === 'function') {
+      return;
+    }
+
+    common.expectsError(
+      () => stream.respond({
+        'content-type': 'text/plain'
+      }, {
+        ['getTrailers']: value
+      }),
+      {
+        type: TypeError,
+        code: 'ERR_INVALID_OPT_VALUE',
+        message: `The value "${String(value)}" is invalid ` +
+                  'for option "getTrailers"'
+      }
+    );
+  });
+
+  // Send headers
+  stream.respond({
+    'content-type': 'text/plain'
+  }, {
+    ['getTrailers']: () => common.mustCall()
+  });
+
+  // Should throw if headers already sent
+  common.expectsError(
+    () => stream.respond(),
+    {
+      type: Error,
+      code: 'ERR_HTTP2_HEADERS_SENT',
+      message: 'Response has already been initiated.'
+    }
   );
 
-  if (currentError.type === 'stream') {
+  // Should throw if stream already destroyed
-    stream.session.on('error', errorMustNotCall);
+  stream.destroy();
-    stream.on('error', errorMustCall);
+  common.expectsError(
-    stream.on('error', common.mustCall(() => {
+    () => stream.respond(),
-      stream.destroy();
+    {
-    }));
+      type: Error,
-  } else {
+      code: 'ERR_HTTP2_INVALID_STREAM',
-    stream.session.once('error', errorMustCall);
+      message: 'The stream has been destroyed'
-    stream.on('error', errorMustNotCall);
+    }
-  }
+  );
+}));
 
-  stream.respond();
+server.listen(0, common.mustCall(() => {
-}, tests.length));
+  const client = http2.connect(`http://localhost:${server.address().port}`);
-
+  const req = client.request();
-server.listen(0, common.mustCall(() => runTest(tests.shift())));
-
-function runTest(test) {
-  const port = server.address().port;
-  const url = `http://localhost:${port}`;
-  const headers = {
-    ':path': '/',
-    ':method': 'POST',
-    ':scheme': 'http',
-    ':authority': `localhost:${port}`
-  };
-
-  const client = http2.connect(url);
-  const req = client.request(headers);
-  req.on('error', common.expectsError({
-    code: 'ERR_HTTP2_STREAM_ERROR',
-    type: Error,
-    message: 'Stream closed with error code 2'
-  }));
-
-  currentError = test;
-  req.resume();
-  req.end();
 
   req.on('end', common.mustCall(() => {
     client.close();
-
+    server.close();
-    if (!tests.length) {
-      server.close();
-    } else {
-      runTest(tests.shift());
-    }
   }));
-}
+  req.resume();
+  req.end();
+}));

test/parallel/test-http2-respond-nghttperrors.js

@@ -0,0 +1,99 @@
+'use strict';
+// Flags: --expose-internals
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const {
+  constants,
+  Http2Stream,
+  nghttp2ErrorString
+} = process.binding('http2');
+const { NghttpError } = require('internal/http2/util');
+
+// tests error handling within respond
+// - every other NGHTTP2 error from binding (should emit stream error)
+
+const specificTestKeys = [];
+
+const specificTests = [];
+
+const genericTests = Object.getOwnPropertyNames(constants)
+  .filter((key) => (
+    key.indexOf('NGHTTP2_ERR') === 0 && specificTestKeys.indexOf(key) < 0
+  ))
+  .map((key) => ({
+    ngError: constants[key],
+    error: {
+      code: 'ERR_HTTP2_ERROR',
+      type: NghttpError,
+      name: 'Error [ERR_HTTP2_ERROR]',
+      message: nghttp2ErrorString(constants[key])
+    },
+    type: 'stream'
+  }));
+
+
+const tests = specificTests.concat(genericTests);
+
+let currentError;
+
+// mock submitResponse because we only care about testing error handling
+Http2Stream.prototype.respond = () => currentError.ngError;
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream, headers) => {
+  const errorMustCall = common.expectsError(currentError.error);
+  const errorMustNotCall = common.mustNotCall(
+    `${currentError.error.code} should emit on ${currentError.type}`
+  );
+
+  if (currentError.type === 'stream') {
+    stream.session.on('error', errorMustNotCall);
+    stream.on('error', errorMustCall);
+    stream.on('error', common.mustCall(() => {
+      stream.destroy();
+    }));
+  } else {
+    stream.session.once('error', errorMustCall);
+    stream.on('error', errorMustNotCall);
+  }
+
+  stream.respond();
+}, tests.length));
+
+server.listen(0, common.mustCall(() => runTest(tests.shift())));
+
+function runTest(test) {
+  const port = server.address().port;
+  const url = `http://localhost:${port}`;
+  const headers = {
+    ':path': '/',
+    ':method': 'POST',
+    ':scheme': 'http',
+    ':authority': `localhost:${port}`
+  };
+
+  const client = http2.connect(url);
+  const req = client.request(headers);
+  req.on('error', common.expectsError({
+    code: 'ERR_HTTP2_STREAM_ERROR',
+    type: Error,
+    message: 'Stream closed with error code 2'
+  }));
+
+  currentError = test;
+  req.resume();
+  req.end();
+
+  req.on('end', common.mustCall(() => {
+    client.close();
+
+    if (!tests.length) {
+      server.close();
+    } else {
+      runTest(tests.shift());
+    }
+  }));
+}