Refine listening SocketAddress construction and add tests

Motivation:

SocketAddress.init(_:) folded address, port and pathname lookups into a
single tuple switch with coarse error cases, making failure reasons
ambiguous and leaving the mapping untested.

Modifications:

- Replace addressOrPortNotAvailable/unsupportedAddressType with the more
  precise addressNotAvailable and portNotAvailable cases
- Rebuild init(_:) around per-field throwing accessors and an exhaustive
  switch over the address kind
- Switch the NIOClient test helper over SocketAddress.base instead of the
  optional host/port/path accessors
- Add SocketAddressTests covering the IPv4, IPv6, UDS and nil mappings

Result:

Listening-address construction has precise error reasons and unit-test
coverage; behaviour is unchanged.

Author: mob-connection

Sources/NIOHTTPServer/NIOHTTPServer+ListeningAddress.swift

@@ -15,19 +15,20 @@
 import NIOConcurrencyHelpers
 import NIOCore
 import NIOPosix
+import System
 
 enum ListeningAddressError: CustomStringConvertible, Error {
-    case addressOrPortNotAvailable
-    case unsupportedAddressType
+    case addressNotAvailable
+    case portNotAvailable
     case serverClosed
     case pathnameNotAvailable
 
     var description: String {
         switch self {
-        case .addressOrPortNotAvailable:
-            return "Unable to retrieve the bound address or port from the underlying socket"
-        case .unsupportedAddressType:
-            return "Unsupported address type: only IPv4 and IPv6 are supported"
+        case .addressNotAvailable:
+            return "Unable to retrieve the bound address from the underlying socket"
+        case .portNotAvailable:
+            return "Unable to retrieve the bound port from the underlying socket"
         case .serverClosed:
             return """
                 There is no listening address bound for this server: there may have been an error which caused the server to close, or it may have shut down.
@@ -138,24 +139,38 @@ extension NIOHTTPServer {
 extension NIOHTTPServer.SocketAddress {
     init(_ address: NIOCore.SocketAddress?) throws(ListeningAddressError) {
         guard let address else {
-            throw .addressOrPortNotAvailable
+            throw .addressNotAvailable
         }
 
-        let base: Base = switch (address, address.port, address.pathname) {
-        case (.v4(let ipv4Address), .some(let port), _):
-                .ipv4(.init(host: ipv4Address.host, port: port))
+        var port: Int {
+            get throws(ListeningAddressError) {
+                guard let port = address.port else {
+                    throw .portNotAvailable
+                }
+                return port
+            }
+        }
+
+        var pathname: String {
+            get throws(ListeningAddressError) {
+                guard let pathname = address.pathname else {
+                    throw .pathnameNotAvailable
+                }
+                return pathname
+            }
+        }
 
-        case (.v6(let ipv6Address), .some(let port), _):
-                .ipv6(.init(host: ipv6Address.host, port: port))
+        let base: NIOHTTPServer.SocketAddress.Base
 
-        case (.unixDomainSocket, _, .some(let path)):
-                .unixDomainSocket(path: path)
+        switch address {
+        case .v4(let ipv4Address):
+            base = try .ipv4(.init(host: ipv4Address.host, port: port))
 
-        case (.v4, .none, _), (.v6, .none, _):
-            throw .addressOrPortNotAvailable
+        case .v6(let ipv6Address):
+            base = try .ipv6(.init(host: ipv6Address.host, port: port))
 
-        case (.unixDomainSocket, _, .none):
-            throw .pathnameNotAvailable
+        case .unixDomainSocket(_):
+            base = try .unixDomainSocket(path: pathname)
         }
 
         self.init(base: base)

Tests/NIOHTTPServerTests/SocketAddressTests.swift

@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift HTTP Server open source project
+//
+// Copyright (c) 2026 Apple Inc. and the Swift HTTP Server project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift HTTP Server project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+import Testing
+
+@testable import NIOHTTPServer
+
+@Suite
+struct SocketAddressTests {
+    @available(anyAppleOS 26.0, *)
+    @Test("A nil NIO address throws addressNotAvailable")
+    func testNilAddressThrows() throws {
+        #expect(throws: ListeningAddressError.addressNotAvailable) {
+            _ = try NIOHTTPServer.SocketAddress(nil as NIOCore.SocketAddress?)
+        }
+    }
+
+    @available(anyAppleOS 26.0, *)
+    @Test("An IPv4 NIO address maps to the ipv4 base")
+    func testIPv4Address() throws {
+        // `makeAddressResolvingHost` populates the address' `host` field the way a real bound
+        // `localAddress` does; `SocketAddress(ipAddress:port:)` would leave `host` empty.
+        let nioAddress = try NIOCore.SocketAddress.makeAddressResolvingHost("127.0.0.1", port: 8080)
+        let address = try NIOHTTPServer.SocketAddress(nioAddress)
+
+        let ipv4 = try #require(address.ipv4)
+        #expect(ipv4.host == "127.0.0.1")
+        #expect(ipv4.port == 8080)
+
+        // Convenience accessors should agree with the concrete IPv4 value.
+        #expect(address.host == "127.0.0.1")
+        #expect(address.port == 8080)
+
+        // It must not masquerade as any other address kind.
+        #expect(address.ipv6 == nil)
+        #expect(address.unixDomainSocketPath == nil)
+    }
+
+    @available(anyAppleOS 26.0, *)
+    @Test("An IPv6 NIO address maps to the ipv6 base")
+    func testIPv6Address() throws {
+        let nioAddress = try NIOCore.SocketAddress.makeAddressResolvingHost("::1", port: 9090)
+        let address = try NIOHTTPServer.SocketAddress(nioAddress)
+
+        let ipv6 = try #require(address.ipv6)
+        #expect(ipv6.host == "::1")
+        #expect(ipv6.port == 9090)
+
+        #expect(address.host == "::1")
+        #expect(address.port == 9090)
+
+        #expect(address.ipv4 == nil)
+        #expect(address.unixDomainSocketPath == nil)
+    }
+
+    @available(anyAppleOS 26.0, *)
+    @Test("A unix domain socket NIO address maps to the unixDomainSocket base")
+    func testUnixDomainSocketAddress() throws {
+        let path = "/tmp/nio-http-server-socket-address-test.sock"
+        let nioAddress = try NIOCore.SocketAddress(unixDomainSocketPath: path)
+        let address = try NIOHTTPServer.SocketAddress(nioAddress)
+
+        #expect(address.unixDomainSocketPath == path)
+
+        // A UDS address exposes neither host nor port.
+        #expect(address.host == nil)
+        #expect(address.port == nil)
+        #expect(address.ipv4 == nil)
+        #expect(address.ipv6 == nil)
+    }
+}

Tests/NIOHTTPServerTests/Utilities/NIOClient/NIOClient+HTTP1.swift

@@ -19,6 +19,8 @@ import NIOHTTPTypes
 import NIOHTTPTypesHTTP1
 import NIOPosix
 
+@testable import NIOHTTPServer
+
 @available(anyAppleOS 26.0, *)
 extension Channel {
     /// Adds HTTP/1.1 client handlers to the pipeline.
@@ -57,12 +59,14 @@ extension ClientBootstrap {
         at serverAddress: NIOHTTPServer.SocketAddress
     ) async throws -> NIOAsyncChannel<HTTPResponsePart, HTTPRequestPart> {
         let target: NIOCore.SocketAddress
-        if let path = serverAddress.unixDomainSocketPath {
+
+        switch serverAddress.base {
+        case .ipv4(let address):
+            target = try NIOCore.SocketAddress(ipAddress: address.host, port: address.port)
+        case .ipv6(let address):
+            target = try NIOCore.SocketAddress(ipAddress: address.host, port: address.port)
+        case .unixDomainSocket(path: let path):
             target = try NIOCore.SocketAddress(unixDomainSocketPath: path)
-        } else if let host = serverAddress.host, let port = serverAddress.port {
-            target = try NIOCore.SocketAddress(ipAddress: host, port: port)
-        } else {
-            throw TestError.unsupportedAddress
         }
 
         return try await self.connect(to: target) { channel in