test: cleanup QUIC tests and migrate them to mjs

Author: jasnell

test/common/index.mjs

@@ -16,6 +16,7 @@ const {
   getBufferSources,
   getTTYfd,
   hasCrypto,
+  hasQuic,
   hasSQLite,
   hasIntl,
   hasIPv6,
@@ -66,6 +67,7 @@ export {
   getPort,
   getTTYfd,
   hasCrypto,
+  hasQuic,
   hasSQLite,
   hasIntl,
   hasIPv6,

test/parallel/test-quic-handshake.js

@@ -0,0 +1,50 @@
+// Flags: --experimental-quic --no-warnings
+
+import { hasQuic, skip } from '../common/index.mjs';
+import { ok, partialDeepStrictEqual } from 'node:assert';
+import { createPrivateKey } from 'node:crypto';
+import { readKey } from '../common/fixtures.mjs';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+// Import after the hasQuic check
+const { listen, connect } = await import('node:quic');
+
+const keys = createPrivateKey(readKey('agent1-key.pem'));
+const certs = readKey('agent1-cert.pem');
+
+const check = {
+  // The SNI value
+  servername: 'localhost',
+  // The selected ALPN protocol
+  protocol: 'h3',
+  // The negotiated cipher suite
+  cipher: 'TLS_AES_128_GCM_SHA256',
+  cipherVersion: 'TLSv1.3',
+};
+
+// The opened promise should resolve when the handshake is complete.
+
+const serverOpened = Promise.withResolvers();
+const clientOpened = Promise.withResolvers();
+
+const serverEndpoint = await listen(async (serverSession) => {
+  const info = await serverSession.opened;
+  partialDeepStrictEqual(info, check);
+  serverOpened.resolve();
+  serverSession.close();
+}, { keys, certs });
+
+// The server must have an address to connect to after listen resolves.
+ok(serverEndpoint.address !== undefined);
+
+const clientSession = await connect(serverEndpoint.address);
+clientSession.opened.then((info) => {
+  partialDeepStrictEqual(info, check);
+  clientOpened.resolve();
+});
+
+await Promise.all([serverOpened.promise, clientOpened.promise]);
+clientSession.close();

test/parallel/test-quic-handshake.mjs

@@ -0,0 +1,72 @@
+// Flags: --expose-internals --experimental-quic --no-warnings
+import { hasQuic, skip } from '../common/index.mjs';
+
+import {
+  ok,
+  rejects,
+  strictEqual,
+  throws,
+} from 'node:assert';
+import { createPrivateKey } from 'node:crypto';
+import { readKey } from '../common/fixtures.mjs';
+import { SocketAddress } from 'node:net';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+// Import after the hasQuic check
+const { listen, QuicEndpoint } = await import('node:quic');
+const { kState } = (await import('internal/quic/symbols')).default;
+
+const keys = createPrivateKey(readKey('agent1-key.pem'));
+const certs = readKey('agent1-cert.pem');
+
+const endpoint = new QuicEndpoint();
+
+ok(!endpoint[kState].isBound);
+ok(!endpoint[kState].isReceiving);
+ok(!endpoint[kState].isListening);
+
+strictEqual(endpoint.address, undefined);
+
+await rejects(listen(123, { keys, certs, endpoint }), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+
+await rejects(listen(() => {}, 123), {
+  code: 'ERR_INVALID_ARG_TYPE',
+});
+
+await listen(() => {}, { keys, certs, endpoint });
+await rejects(listen(() => {}, { keys, certs, endpoint }), {
+  code: 'ERR_INVALID_STATE',
+});
+
+ok(endpoint[kState].isBound);
+ok(endpoint[kState].isReceiving);
+ok(endpoint[kState].isListening);
+
+const address = endpoint.address;
+ok(address instanceof SocketAddress);
+
+strictEqual(address.address, '127.0.0.1');
+strictEqual(address.family, 'ipv4');
+strictEqual(address.flowlabel, 0);
+ok(address.port !== 0);
+
+ok(!endpoint.destroyed);
+endpoint.destroy();
+strictEqual(endpoint.closed, endpoint.close());
+await endpoint.closed;
+ok(endpoint.destroyed);
+
+await rejects(listen(() => {}, { keys, certs, endpoint }), {
+  code: 'ERR_INVALID_STATE',
+});
+throws(() => { endpoint.busy = true; }, {
+  code: 'ERR_INVALID_STATE',
+});
+await endpoint[Symbol.asyncDispose]();
+
+strictEqual(endpoint.address, undefined);