test: clean up some dtls tests

Use timers/promise setTimeout and fix a hang in a test

Signed-off-by: James M Snell <[email protected]>

Author: jasnell

test/parallel/test-dtls-error-queue.mjs

@@ -11,10 +11,9 @@
 // "SSL routines::record too small".
 
 import { hasCrypto, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
-import crypto from 'node:crypto';
-import dgram from 'node:dgram';
 
 if (!hasCrypto) {
   skip('missing crypto');
@@ -24,6 +23,9 @@ if (!process.features.dtls) {
   skip('DTLS is not enabled');
 }
 
+const crypto = await import('node:crypto');
+const dgram = await import('node:dgram');
+
 const { connect, listen } = await import('node:dtls');
 
 const cert = fixtures.readKey('agent1-cert.pem');
@@ -61,7 +63,7 @@ for (let i = 0; i < 32; i++) {
 }
 // Let the datagrams reach the endpoint and be processed before closing;
 // dgram.close() does not flush queued sends.
-await new Promise((resolve) => setTimeout(resolve, 200));
+await setTimeout(200);
 await new Promise((resolve) => socket.close(resolve));
 
 // An unrelated crypto failure must report its own cause. Before the error

test/parallel/test-dtls-handshake-timeout.mjs

@@ -10,6 +10,7 @@
 // which has to keep its own timing.
 
 import { hasCrypto, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import assert from 'node:assert';
 
 if (!hasCrypto) {
@@ -96,10 +97,10 @@ function serve(options = {}) {
     stalled.push(client);
   }
 
-  await new Promise((resolve) => setTimeout(resolve, 150));
+  await setTimeout(150);
   assert.strictEqual(Number(getDTLSEndpointState(endpoint).sessionCount), 3);
 
-  await new Promise((resolve) => setTimeout(resolve, 600));
+  await setTimeout(600);
   assert.strictEqual(Number(getDTLSEndpointState(endpoint).sessionCount), 0);
 
   // And the endpoint is usable again.
@@ -123,7 +124,7 @@ function serve(options = {}) {
   });
   await client.opened;
 
-  await new Promise((resolve) => setTimeout(resolve, 600));
+  await setTimeout(600);
   assert.strictEqual(getDTLSSessionState(client).destroyed, false);
 
   // Still usable well after the deadline would have passed.
@@ -149,7 +150,7 @@ function serve(options = {}) {
   const pending = Symbol('pending');
   const outcome = await Promise.race([
     client.opened.then(() => 'opened', () => 'failed'),
-    new Promise((resolve) => setTimeout(resolve, 500, pending)),
+    setTimeout(500, pending),
   ]);
   assert.strictEqual(outcome, pending);
 
@@ -167,7 +168,7 @@ function serve(options = {}) {
   const pending = Symbol('pending');
   const outcome = await Promise.race([
     client.opened.then(() => 'opened', () => 'failed'),
-    new Promise((resolve) => setTimeout(resolve, 500, pending)),
+    setTimeout(500, pending),
   ]);
   assert.strictEqual(outcome, pending);
 

test/parallel/test-dtls-max-sessions.mjs

@@ -6,6 +6,7 @@
 // nothing used to bound how many of them a peer could accumulate.
 
 import { hasCrypto, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -35,9 +36,7 @@ const ca = fixtures.readKey('ca1-cert.pem');
 // retransmit schedule.
 async function tryConnect(port, timeout = 1500) {
   const client = connect('127.0.0.1', port, { servername: 'agent1', ca: [ca] });
-  const timer = new Promise((resolve) => {
-    setTimeout(resolve, timeout).unref();
-  });
+  const timer = setTimeout(timeout, undefined, { ref: false });
   const opened = await Promise.race([
     client.opened.then(() => true, () => false),
     timer.then(() => false),
@@ -50,9 +49,7 @@ async function tryConnect(port, timeout = 1500) {
 async function waitForSessionCount(server, expected) {
   for (let i = 0; i < 100; i++) {
     if (getDTLSEndpointState(server).sessionCount === expected) return;
-    await new Promise((resolve) => {
-      setTimeout(resolve, 10).unref();
-    });
+    await setTimeout(10, undefined, { ref: false });
   }
   assert.strictEqual(getDTLSEndpointState(server).sessionCount, expected);
 }

test/parallel/test-dtls-message-listener-gate.mjs

@@ -14,6 +14,7 @@
 // drained.
 
 import { hasCrypto, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -49,7 +50,7 @@ await session.opened;
 async function waitForMessages(count) {
   for (let i = 0; i < 100; i++) {
     if (session.stats.messagesReceived >= count) return;
-    await new Promise((resolve) => setTimeout(resolve, 20));
+    await setTimeout(20);
   }
   assert.fail(`only ${session.stats.messagesReceived} of ${count} messages ` +
               'were read; data is not being drained');

test/parallel/test-dtls-opened-settles.mjs

@@ -7,6 +7,7 @@
 // left anyone awaiting `opened` waiting forever, with no error and no timeout.
 
 import { hasCrypto, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -24,13 +25,18 @@ const cert = fixtures.readKey('agent1-cert.pem');
 const key = fixtures.readKey('agent1-key.pem');
 const ca = fixtures.readKey('ca1-cert.pem');
 
+async function sleep(n) {
+  await setTimeout(1000);
+  return 'pending';
+}
+
 // Resolves to the promise's outcome, or 'pending' if it has not settled by
 // the time the microtask queue and a timer have both drained. Awaiting
 // `opened` directly would hang the test rather than fail it.
 function outcome(promise) {
   return Promise.race([
     promise.then(() => 'resolved', (err) => err),
-    new Promise((resolve) => setTimeout(() => resolve('pending'), 1000)),
+    sleep(1000),
   ]);
 }
 
@@ -173,12 +179,12 @@ function newClient() {
 {
   const endpoint = listen(() => {}, { cert, key, host: '127.0.0.1', port: 0 });
   const client = connect('127.0.0.1', endpoint.address.port, {
+    handshakeTimeout: 500,
     rejectUnauthorized: false,
   });
 
   // Before the handshake can finish.
   endpoint.destroy();
-
   await assert.rejects(client.opened, { name: 'Error' });
   await client.close();
 }

test/parallel/test-dtls-peer-x509-certificate.mjs

@@ -10,7 +10,6 @@
 import { hasCrypto, skip } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
-import { X509Certificate } from 'node:crypto';
 
 if (!hasCrypto) {
   skip('missing crypto');
@@ -20,6 +19,7 @@ if (!process.features.dtls) {
   skip('DTLS is not enabled');
 }
 
+const { X509Certificate } = await import('node:crypto');
 const { connect, listen } = await import('node:dtls');
 
 // A leaf issued by an intermediate, so there is a real chain to walk. The

test/parallel/test-dtls-psk.mjs

@@ -7,6 +7,7 @@
 // mandatory to implement for CoAP.
 
 import { hasCrypto, mustCall, mustNotCall, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -119,7 +120,7 @@ function open(endpoint, options) {
   const stalled = Symbol('stalled');
   const outcome = await Promise.race([
     client.opened.then(() => 'opened', () => 'rejected'),
-    new Promise((resolve) => setTimeout(resolve, 200, stalled)),
+    setTimeout(200, stalled),
   ]);
   assert.strictEqual(outcome, stalled);
 

test/parallel/test-dtls-server-handshake-error.mjs

@@ -8,6 +8,7 @@
 // connect and heard nothing at all.
 
 import { hasCrypto, mustCall, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -36,18 +37,10 @@ async function within(promise, what, ms = 5000) {
   const late = Symbol('late');
   // The timer has to be cleared: left pending it holds the loop open for its
   // full duration after the race is already decided.
-  let timer;
-  try {
-    const result = await Promise.race([
-      promise,
-      new Promise((resolve) => { timer = setTimeout(resolve, ms, late); }),
-    ]);
-    assert.notStrictEqual(result, late,
-                          `${what} did not happen within ${ms}ms`);
-    return result;
-  } finally {
-    clearTimeout(timer);
-  }
+  const result = await Promise.race([promise, setTimeout(ms, late, { ref: false })]);
+  assert.notStrictEqual(result, late,
+                        `${what} did not happen within ${ms}ms`);
+  return result;
 }
 const key = (name) => fixtures.readKey(name).toString();
 const cert = key('agent1-cert.pem');
@@ -137,7 +130,7 @@ const privateKey = key('agent1-key.pem');
   const pending = Symbol('pending');
   await Promise.race([
     client.opened.then(() => 'opened', () => 'failed'),
-    new Promise((resolve) => setTimeout(resolve, 300, pending)),
+    setTimeout(300, pending),
   ]);
 
   assert.strictEqual(Number(getDTLSEndpointState(endpoint).sessionCount), 0);
@@ -148,7 +141,7 @@ const privateKey = key('agent1-key.pem');
   });
   const outcome = await Promise.race([
     good.opened.then(() => 'opened', () => 'failed'),
-    new Promise((resolve) => setTimeout(resolve, 500, pending)),
+    setTimeout(500, pending),
   ]);
   assert.notStrictEqual(outcome, pending);
 

test/parallel/test-dtls-session-resumption.mjs

@@ -12,7 +12,6 @@
 import { hasCrypto, skip } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
-import { randomBytes } from 'node:crypto';
 import { inspect } from 'node:util';
 
 if (!hasCrypto) {
@@ -23,8 +22,8 @@ if (!process.features.dtls) {
   skip('DTLS is not enabled');
 }
 
-const dtls = await import('node:dtls');
-const { connect, createSecureContext, listen } = dtls;
+const { randomBytes } = await import('node:crypto');
+const { connect, createSecureContext, listen } = await import('node:dtls');
 
 const key = (name) => fixtures.readKey(name).toString();
 const cert = key('agent1-cert.pem');

test/parallel/test-dtls-sni.mjs

@@ -10,6 +10,7 @@
 // suspended DTLS handshake keeps retransmitting.
 
 import { hasCrypto, mustNotCall, skip } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 
@@ -30,20 +31,10 @@ const key = (name) => fixtures.readKey(name).toString();
 // until the runner gives up.
 async function within(promise, what, ms = 5000) {
   const late = Symbol('late');
-  // The timer has to be cleared: left pending it holds the loop open for its
-  // full duration after the race is already decided.
-  let timer;
-  try {
-    const result = await Promise.race([
-      promise,
-      new Promise((resolve) => { timer = setTimeout(resolve, ms, late); }),
-    ]);
-    assert.notStrictEqual(result, late,
-                          `${what} did not happen within ${ms}ms`);
-    return result;
-  } finally {
-    clearTimeout(timer);
-  }
+  const result = await Promise.race([promise, setTimeout(ms, late, { ref: false })]);
+  assert.notStrictEqual(result, late,
+                        `${what} did not happen within ${ms}ms`);
+  return result;
 }
 
 const agent1Cert = key('agent1-cert.pem');