quic: add QuicEndpoint.listening & QuicStream.destroy() and tests

Starting to explore and cover the existing implementation, this covers
the basic endpoint & stream lifecycle and the exposed properties.
Added endpoint.listening to match net.Server and round out endpoint
properties, and stream.destroy() which is already called by
quicSession.destroy() and documented, but didn't actually exist.
Signed-off-by: Tim Perry <pimterry@gmail.com>
PR-URL: #62648
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: pimterry

doc/api/quic.md

@@ -204,6 +204,12 @@ added: v23.8.0
 
 True if `endpoint.destroy()` has been called. Read only.
 
+### `endpoint.listening`
+
+* Type: {boolean}
+
+True if the endpoint is actively listening for incoming connections. Read only.
+
 ### `endpoint.setSNIContexts(entries[, options])`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -720,7 +720,25 @@ class QuicStream {
 }
 
 /**
- * @param {ArrayBuffer|ArrayBufferView|Blob} outbound
+ * Immediately destroys the stream. Any queued data is discarded. If an
+ * error is given, the closed promise will be rejected with that error.
+ * If no error is given, the closed promise will be resolved.
+ * @param {any} error
+ */
+destroy(error){
+if(this.destroyed)return;
+consthandle=this.#handle;
+this[kFinishClose](error);
+handle.destroy();
+}
+
+/**
+ * Sets the outbound data source for the stream. This can only be called
+ * once and must be called before any data will be sent. The body can be
+ * an ArrayBuffer, a TypedArray or DataView, or a Blob. If the stream
+ * is destroyed or already has an outbound data source, an error will
+ * be thrown.
+ * @param {ArrayBuffer|SharedArrayBuffer|ArrayBufferView|Blob} outbound
  */
 setOutbound(outbound){
 if(this.destroyed){
@@ -1748,7 +1766,14 @@ class QuicEndpoint {
 getclosing(){returnthis.#isPendingClose;}
 
 /** @type {boolean} */
-getdestroyed(){returnthis.#handle ===undefined;}
+getlistening(){
+returnthis.#listening;
+}
+
+/** @type {boolean} */
+getdestroyed(){
+returnthis.#handle ===undefined;
+}
 
 /**
  * Forcefully terminates the endpoint by immediately destroying all sessions

test/parallel/test-quic-session-stream-lifecycle.mjs

@@ -0,0 +1,98 @@
+// Flags: --experimental-quic --no-warnings
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+importassertfrom'node:assert';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+// Import after the hasQuic check
+constquic=awaitimport('node:quic');
+const{ createPrivateKey }=awaitimport('node:crypto');
+
+constkeys=createPrivateKey(fixtures.readKey('agent1-key.pem'));
+constcerts=fixtures.readKey('agent1-cert.pem');
+
+constserverDone=Promise.withResolvers();
+constclientDone=Promise.withResolvers();
+
+// Create a server endpoint
+constserverEndpoint=awaitquic.listen(mustCall((serverSession)=>{
+serverSession.opened.then((info)=>{
+assert.ok(serverSession.endpoint!==null);
+assert.strictEqual(serverSession.destroyed,false);
+
+conststats=serverSession.stats;
+assert.strictEqual(stats.isConnected,true);
+assert.ok(stats.handshakeCompletedAt>0n);
+assert.ok(stats.handshakeConfirmedAt>0n);
+assert.strictEqual(stats.closingAt,0n);
+
+serverDone.resolve();
+serverSession.close();
+}).then(mustCall());
+}),{sni: {'*': { keys, certs }}});
+
+assert.strictEqual(serverEndpoint.busy,false);
+assert.strictEqual(serverEndpoint.closing,false);
+assert.strictEqual(serverEndpoint.destroyed,false);
+assert.strictEqual(serverEndpoint.listening,true);
+
+assert.ok(serverEndpoint.address!==undefined);
+assert.strictEqual(serverEndpoint.address.family,'ipv4');
+assert.strictEqual(serverEndpoint.address.address,'127.0.0.1');
+assert.ok(typeofserverEndpoint.address.port==='number');
+assert.ok(serverEndpoint.address.port>0);
+
+constepStats=serverEndpoint.stats;
+assert.strictEqual(epStats.isConnected,true);
+assert.ok(epStats.createdAt>0n);
+
+// Connect with a client
+constclientSession=awaitquic.connect(serverEndpoint.address);
+
+assert.strictEqual(clientSession.destroyed,false);
+assert.ok(clientSession.endpoint!==null);
+assert.strictEqual(clientSession.stats.isConnected,true);
+
+clientSession.opened.then((clientInfo)=>{
+assert.strictEqual(clientInfo.servername,'localhost');
+assert.strictEqual(clientInfo.protocol,'h3');
+assert.strictEqual(clientInfo.cipherVersion,'TLSv1.3');
+assert.ok(clientInfo.local!==undefined);
+assert.ok(clientInfo.remote!==undefined);
+
+constcStats=clientSession.stats;
+assert.strictEqual(cStats.isConnected,true);
+assert.ok(cStats.handshakeCompletedAt>0n);
+assert.ok(cStats.bytesSent>0n,'Expected bytesSent > 0 after handshake');
+
+clientDone.resolve();
+}).then(mustCall());
+
+awaitPromise.all([serverDone.promise,clientDone.promise]);
+
+// Open a bidirectional stream.
+conststream=awaitclientSession.createBidirectionalStream();
+
+assert.strictEqual(stream.destroyed,false);
+assert.strictEqual(stream.direction,'bidi');
+assert.strictEqual(stream.session,clientSession);
+assert.ok(stream.id!==null,'Non-pending stream should have an id');
+assert.strictEqual(typeofstream.id,'bigint');
+assert.strictEqual(stream.pending,false);
+assert.strictEqual(stream.stats.isConnected,true);
+assert.ok(stream.readableinstanceofReadableStream);
+
+// Destroying the session should destroy it and the stream, and clear its properties.
+clientSession.destroy();
+assert.strictEqual(clientSession.destroyed,true);
+assert.strictEqual(clientSession.endpoint,null);
+assert.strictEqual(clientSession.stats.isConnected,false);
+
+assert.strictEqual(stream.destroyed,true);
+assert.strictEqual(stream.session,null);
+assert.strictEqual(stream.id,null);
+assert.strictEqual(stream.direction,null);