test: http2 client settings errors

Refs: https://github.com/nodejs/node/issues/14985
PR-URL: https://github.com/nodejs/node/pull/16096
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

test/parallel/test-http2-client-settings-errors.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const {
+  constants,
+  Http2Session,
+  nghttp2ErrorString
+} = process.binding('http2');
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+
+// tests error handling within requestOnConnect
+// - NGHTTP2_ERR_NOMEM (should emit session error)
+// - every other NGHTTP2 error from binding (should emit session error)
+
+const specificTestKeys = [
+  'NGHTTP2_ERR_NOMEM'
+];
+
+const specificTests = [
+  {
+    ngError: constants.NGHTTP2_ERR_NOMEM,
+    error: {
+      code: 'ERR_OUTOFMEMORY',
+      type: Error,
+      message: 'Out of memory'
+    }
+  }
+];
+
+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: Error,
+      message: nghttp2ErrorString(constants[key])
+    }
+  }));
+
+const tests = specificTests.concat(genericTests);
+
+const server = http2.createServer(common.mustNotCall());
+server.on('sessionError', () => {}); // not being tested
+
+server.listen(0, common.mustCall(() => runTest(tests.shift())));
+
+function runTest(test) {
+  // mock submitSettings because we only care about testing error handling
+  Http2Session.prototype.submitSettings = () => test.ngError;
+
+  const errorMustCall = common.expectsError(test.error);
+  const errorMustNotCall = common.mustNotCall(
+    `${test.error.code} should emit on session`
+  );
+
+  const url = `http://localhost:${server.address().port}`;
+
+  const client = http2.connect(url, {
+    settings: {
+      maxHeaderListSize: 1
+    }
+  });
+
+  const req = client.request();
+  req.resume();
+  req.end();
+
+  client.on('error', errorMustCall);
+  req.on('error', errorMustNotCall);
+
+  req.on('end', common.mustCall(() => {
+    client.destroy();
+    if (!tests.length) {
+      server.close();
+    } else {
+      runTest(tests.shift());
+    }
+  }));
+}

test/parallel/test-http2-session-settings.js

@@ -8,9 +8,10 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 
-server.on('stream', common.mustCall(onStream));
+server.on(
-
+  'stream',
-function assertSettings(settings) {
+  common.mustCall((stream) => {
+    const assertSettings = (settings) => {
       assert.strictEqual(typeof settings, 'object');
       assert.strictEqual(typeof settings.headerTableSize, 'number');
       assert.strictEqual(typeof settings.enablePush, 'boolean');
@@ -18,9 +19,7 @@ function assertSettings(settings) {
       assert.strictEqual(typeof settings.maxFrameSize, 'number');
       assert.strictEqual(typeof settings.maxConcurrentStreams, 'number');
       assert.strictEqual(typeof settings.maxHeaderListSize, 'number');
-}
+    };
-
-function onStream(stream, headers, flags) {
 
     const localSettings = stream.session.localSettings;
     const remoteSettings = stream.session.remoteSettings;
@@ -36,12 +35,12 @@ function onStream(stream, headers, flags) {
       ':status': 200
     });
     stream.end('hello world');
-}
+  })
-
+);
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
 
+server.listen(
+  0,
+  common.mustCall(() => {
     const client = h2.connect(`http://localhost:${server.address().port}`, {
       settings: {
         enablePush: false,
@@ -49,28 +48,39 @@ server.on('listening', common.mustCall(() => {
       }
     });
 
-  client.on('localSettings', common.mustCall((settings) => {
+    client.on(
+      'localSettings',
+      common.mustCall((settings) => {
         assert(settings);
         assert.strictEqual(settings.enablePush, false);
         assert.strictEqual(settings.initialWindowSize, 123456);
         assert.strictEqual(settings.maxFrameSize, 16384);
-  }, 2));
+      }, 2)
-  client.on('remoteSettings', common.mustCall((settings) => {
+    );
+    client.on(
+      'remoteSettings',
+      common.mustCall((settings) => {
         assert(settings);
-  }));
+      })
+    );
 
     const headers = { ':path': '/' };
 
     const req = client.request(headers);
 
-  req.on('connect', common.mustCall(() => {
+    req.on(
+      'connect',
+      common.mustCall(() => {
         // pendingSettingsAck will be true if a SETTINGS frame
         // has been sent but we are still waiting for an acknowledgement
         assert(client.pendingSettingsAck);
-  }));
+      })
+    );
 
     // State will only be valid after connect event is emitted
-  req.on('ready', common.mustCall(() => {
+    req.on(
+      'ready',
+      common.mustCall(() => {
         assert.doesNotThrow(() => {
           client.settings({
             maxHeaderListSize: 1
@@ -90,28 +100,39 @@ server.on('listening', common.mustCall(() => {
         ].forEach((i) => {
           const settings = {};
           settings[i[0]] = i[1];
-      assert.throws(() => client.settings(settings),
+          common.expectsError(
-                    common.expectsError({
+            () => client.settings(settings),
+            {
+              type: RangeError,
               code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-                      type: RangeError
+              message: `Invalid value for setting "${i[0]}": ${i[1]}`
-                    }));
+            }
-    });
+          );
-    [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
-      assert.throws(() => client.settings({ enablePush: i }),
-                    common.expectsError({
-                      code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
-                      type: TypeError
-                    }));
         });
 
-  }));
+        // error checks for enablePush
+        [1, {}, 'test', [], null, Infinity, NaN].forEach((i) => {
+          common.expectsError(
+            () => client.settings({ enablePush: i }),
+            {
+              type: TypeError,
+              code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
+              message: `Invalid value for setting "enablePush": ${i}`
+            }
+          );
+        });
+      })
+    );
 
     req.on('response', common.mustCall());
     req.resume();
-  req.on('end', common.mustCall(() => {
+    req.on(
+      'end',
+      common.mustCall(() => {
         server.close();
         client.destroy();
-  }));
+      })
+    );
     req.end();
-
+  })
-}));
+);