Improvement: lifetime-valid close observation, fast closed-connection rejection, and portable loopback dialing in the test harness.

Author: hjdhjd

src/lib/util/eventedhttp.spec.ts

@@ -15,10 +15,12 @@ describe("eventedhttp", () => {
   };
 
   // Creates a connected client and registers it for teardown. One client instance owns one TCP connection, which is
-  // exactly one server-side HAPConnection.
+  // exactly one server-side HAPConnection. The server binds the unspecified address, which is not a portable connect
+  // destination, so we dial the loopback address of the bound family instead.
   const connectClient = async (): Promise<HAPHTTPClient> => {
     const address = server.address();
-    const client = new HAPHTTPClient(address.address, address.port);
+    const host = ["0.0.0.0", "::"].includes(address.address) ? ((address.family === "IPv6") ? "::1" : "127.0.0.1") : address.address;
+    const client = new HAPHTTPClient(host, address.port);
     await client.connect();
     clients.push(client);
     return client;

src/test-utils/HAPHTTPClient.ts

@@ -7,7 +7,6 @@ import { HAPHTTPCode, HAPPairingHTTPCode } from "../lib/HAPServer";
 import { PairingInformation, PermissionTypes } from "../lib/model/AccessoryInfo";
 import { HAPEncryption, HAPUsername } from "../lib/util/eventedhttp";
 import * as hapCrypto from "../lib/util/hapCrypto";
-import { awaitEventOnce } from "../lib/util/promise-utils";
 import * as tlv from "../lib/util/tlv";
 import {
   AccessoriesResponse,
@@ -65,6 +64,9 @@ export class HAPHTTPClient {
   private currentSocket?: Socket;
   private encryption?: HAPEncryption;
   private socketClosed = false;
+  // Settles when the underlying socket has fully closed. Captured at connect() so close observation stays valid for the
+  // client's entire lifetime, even after destroy() has dropped the socket reference.
+  private socketClosePromise?: Promise<void>;
   private everConnected = false;
 
   private currentDataListener?: (data: Buffer) => void;
@@ -95,8 +97,11 @@ export class HAPHTTPClient {
     // A permanent error listener must exist for the socket's lifetime: without one, a late ECONNRESET (e.g. the server
     // tearing down first in afterEach) would crash the process. Failures surface loudly through receive timeouts instead.
     socket.on("error", () => {});
-    socket.on("close", () => {
-      this.socketClosed = true;
+    this.socketClosePromise = new Promise(resolve => {
+      socket.once("close", () => {
+        this.socketClosed = true;
+        resolve();
+      });
     });
 
     this.currentDataListener = data => {
@@ -133,15 +138,24 @@ export class HAPHTTPClient {
   }
 
   /**
-   * Resolves once the underlying socket has fully closed, rejecting after {@link timeoutMs} if it never does. The direct
-   * observation primitive for tests asserting that the server tears a connection down.
+   * Resolves once the underlying socket has fully closed, rejecting after {@link timeoutMs} if it never does. Close
+   * observation is anchored to the promise captured at {@link connect}, so it is valid at any point in the client's
+   * lifetime - including immediately after {@link destroy} - regardless of which side initiates the teardown.
    */
   async waitForClose(timeoutMs = HAPHTTPClient.RECEIVE_TIMEOUT): Promise<void> {
-    if (this.socketClosed) {
-      return;
+    expect(this.socketClosePromise).toBeDefined();
+
+    let timeoutId: NodeJS.Timeout | undefined = undefined;
+
+    const timeout = new Promise<void>((_resolve, reject) => {
+      timeoutId = setTimeout(() => reject(new Error("Timed out awaiting the connection to close.")), timeoutMs);
+    });
+
+    try {
+      await Promise.race([this.socketClosePromise, timeout]);
+    } finally {
+      clearTimeout(timeoutId);
     }
-    expect(this.currentSocket).toBeDefined();
-    await awaitEventOnce(this.currentSocket!, "close", timeoutMs);
   }
 
   get receiveBufferCount(): number {
@@ -179,6 +193,12 @@ export class HAPHTTPClient {
   private awaitIncomingData(deadline: number): Promise<void> {
     expect(this.currentSocket).toBeDefined();
 
+    // A connection that has already closed can never deliver the awaited bytes - reject immediately rather than riding
+    // out the deadline only to fail with the less specific timeout error.
+    if (this.socketClosed) {
+      return Promise.reject(new Error("Connection closed while awaiting incoming data."));
+    }
+
     const socket = this.currentSocket!;
 
     return new Promise((resolve, reject) => {