test: fix flaky test-https-set-timeout-server

Because of a race condition, connection listener may not be invoked if
test is run under load. Remove `common.mustCall()` wrapper from the
listener. Move the test to `parallel` because it now works under load.
Make similar change to http test to keep them in synch even though it is
much harder to trigger the race in http.

PR-URL: https://github.com/nodejs/node/pull/14134
Fixes: https://github.com/nodejs/node/issues/14133
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>

1 files changed, 202 insertions, 0 deletions

diff --git a/test/parallel/test-https-set-timeout-server.js b/test/parallel/test-https-set-timeout-server.js
new file mode 100644
index 0000000000..7642538523
--- /dev/null
+++ b/test/parallel/test-https-set-timeout-server.js
@@ -0,0 +1,202 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const tls = require('tls');
+
+const tests = [];
+
+const serverOptions = {
+  key: fs.readFileSync(`${common.fixturesDir}/keys/agent1-key.pem`),
+  cert: fs.readFileSync(`${common.fixturesDir}/keys/agent1-cert.pem`)
+};
+
+function test(fn) {
+  if (!tests.length)
+    process.nextTick(run);
+  tests.push(common.mustCall(fn));
+}
+
+function run() {
+  const fn = tests.shift();
+  if (fn) {
+    fn(run);
+  }
+}
+
+test(function serverTimeout(cb) {
+  const server = https.createServer(
+    serverOptions,
+    (req, res) => {
+      // Do nothing. We should get a timeout event.
+      // Might not be invoked. Do not wrap in common.mustCall().
+    });
+  server.listen(common.mustCall(() => {
+    const s = server.setTimeout(50, common.mustCall((socket) => {
+      socket.destroy();
+      server.close();
+      cb();
+    }));
+    assert.ok(s instanceof https.Server);
+    https.get({
+      port: server.address().port,
+      rejectUnauthorized: false
+    }).on('error', common.mustCall());
+  }));
+});
+
+test(function serverRequestTimeout(cb) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = req.setTimeout(50, common.mustCall((socket) => {
+        socket.destroy();
+        server.close();
+        cb();
+      }));
+      assert.ok(s instanceof http.IncomingMessage);
+    }));
+  server.listen(common.mustCall(() => {
+    const req = https.request({
+      port: server.address().port,
+      method: 'POST',
+      rejectUnauthorized: false
+    });
+    req.on('error', common.mustCall());
+    req.write('Hello');
+    // req is in progress
+  }));
+});
+
+test(function serverResponseTimeout(cb) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = res.setTimeout(50, common.mustCall((socket) => {
+        socket.destroy();
+        server.close();
+        cb();
+      }));
+      assert.ok(s instanceof http.OutgoingMessage);
+    }));
+  server.listen(common.mustCall(() => {
+    https.get({
+      port: server.address().port,
+      rejectUnauthorized: false
+    }).on('error', common.mustCall());
+  }));
+});
+
+test(function serverRequestNotTimeoutAfterEnd(cb) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      // just do nothing, we should get a timeout event.
+      const s = req.setTimeout(50, common.mustNotCall());
+      assert.ok(s instanceof http.IncomingMessage);
+      res.on('timeout', common.mustCall());
+    }));
+  server.on('timeout', common.mustCall((socket) => {
+    socket.destroy();
+    server.close();
+    cb();
+  }));
+  server.listen(common.mustCall(() => {
+    https.get({
+      port: server.address().port,
+      rejectUnauthorized: false
+    }).on('error', common.mustCall());
+  }));
+});
+
+test(function serverResponseTimeoutWithPipeline(cb) {
+  let caughtTimeout = '';
+  let secReceived = false;
+  process.on('exit', () => {
+    assert.strictEqual(caughtTimeout, '/2');
+  });
+  const server = https.createServer(serverOptions, (req, res) => {
+    if (req.url === '/2')
+      secReceived = true;
+    const s = res.setTimeout(50, () => {
+      caughtTimeout += req.url;
+    });
+    assert.ok(s instanceof http.OutgoingMessage);
+    if (req.url === '/1') res.end();
+  });
+  server.on('timeout', common.mustCall((socket) => {
+    if (secReceived) {
+      socket.destroy();
+      server.close();
+      cb();
+    }
+  }));
+  server.listen(common.mustCall(() => {
+    const options = {
+      port: server.address().port,
+      allowHalfOpen: true,
+      rejectUnauthorized: false
+    };
+    const c = tls.connect(options, () => {
+      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+      c.write('GET /2 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+      c.write('GET /3 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+    });
+  }));
+});
+
+test(function idleTimeout(cb) {
+  const server = https.createServer(
+    serverOptions,
+    common.mustCall((req, res) => {
+      req.on('timeout', common.mustNotCall());
+      res.on('timeout', common.mustNotCall());
+      res.end();
+    }));
+  const s = server.setTimeout(50, common.mustCall((socket) => {
+    socket.destroy();
+    server.close();
+    cb();
+  }));
+  assert.ok(s instanceof https.Server);
+  server.listen(common.mustCall(() => {
+    const options = {
+      port: server.address().port,
+      allowHalfOpen: true,
+      rejectUnauthorized: false
+    };
+    const c = tls.connect(options, () => {
+      c.write('GET /1 HTTP/1.1\r\nHost: localhost\r\n\r\n');
+      // Keep-Alive
+    });
+  }));
+});