test: improve test-async-hooks-http-parser-destroy

Improve asserts to distinguish between reequest and response parsers.

Change the assert sequence to first assert on the number of ids to
easier identify if some operation is missing/incomplete.

Destroy HTTP agent once expected number of events have been seen to
avoid waiting on socket timeouts.

Refs: #28112

Author: Flarna

test/parallel/test-async-hooks-http-parser-destroy.js

@@ -11,19 +11,34 @@ const http = require('http');
 const N = 50;
 const KEEP_ALIVE = 100;
 
-const createdIds = [];
-const destroyedIds = [];
+const createdIdsIncomingMessage = [];
+const createdIdsClientRequest = [];
+const destroyedIdsIncomingMessage = [];
+const destroyedIdsClientRequest = [];
+
 async_hooks.createHook({
   init: (asyncId, type) => {
-    if (type === 'HTTPINCOMINGMESSAGE' || type === 'HTTPCLIENTREQUEST') {
-      createdIds.push(asyncId);
+    if (type === 'HTTPINCOMINGMESSAGE') {
+      createdIdsIncomingMessage.push(asyncId);
+    }
+    if (type === 'HTTPCLIENTREQUEST') {
+      createdIdsClientRequest.push(asyncId);
     }
   },
   destroy: (asyncId) => {
-    if (createdIds.includes(asyncId)) {
-      destroyedIds.push(asyncId);
+    if (createdIdsIncomingMessage.includes(asyncId)) {
+      destroyedIdsIncomingMessage.push(asyncId);
     }
-    if (destroyedIds.length === 2 * N) {
+    if (createdIdsClientRequest.includes(asyncId)) {
+      destroyedIdsClientRequest.push(asyncId);
+    }
+
+    if (destroyedIdsClientRequest.length === N && keepAliveAgent) {
+      keepAliveAgent.destroy();
+      keepAliveAgent = undefined;
+    }
+
+    if (destroyedIdsIncomingMessage.length === N && server.listening) {
       server.close();
     }
   }
@@ -33,28 +48,34 @@ const server = http.createServer((req, res) => {
   res.end('Hello');
 });
 
-const keepAliveAgent = new http.Agent({
+let keepAliveAgent = new http.Agent({
   keepAlive: true,
   keepAliveMsecs: KEEP_ALIVE,
 });
 
-server.listen(0, function() {
+server.listen(0, () => {
   for (let i = 0; i < N; ++i) {
     (function makeRequest() {
       http.get({
         port: server.address().port,
         agent: keepAliveAgent
-      }, function(res) {
+      }, (res) => {
         res.resume();
       });
     })();
   }
 });
 
 function checkOnExit() {
-  assert.deepStrictEqual(destroyedIds.sort(), createdIds.sort());
-  // There should be two IDs for each request.
-  assert.strictEqual(createdIds.length, N * 2);
+  assert.strictEqual(createdIdsIncomingMessage.length, N);
+  assert.strictEqual(createdIdsClientRequest.length, N);
+  assert.strictEqual(destroyedIdsIncomingMessage.length, N);
+  assert.strictEqual(destroyedIdsClientRequest.length, N);
+
+  assert.deepStrictEqual(destroyedIdsIncomingMessage.sort(),
+                         createdIdsIncomingMessage.sort());
+  assert.deepStrictEqual(destroyedIdsClientRequest.sort(),
+                         createdIdsClientRequest.sort());
 }
 
 process.on('SIGTERM', () => {