Changed NWDNSError into an enum

Author: adam-fowler

Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift

@@ -19,26 +19,87 @@ import NIO
 import NIOHTTP1
 import NIOTransportServices
 
-public struct NWDNSError: Error {
-    
-    /// DNS error type. Error type list is defined in <dns_sd.h>
-    public let errorType: DNSServiceErrorType
-    
-    /// actual reason, in human readable form
-    private let reason: String
-    
-    /// Initialise a NWDNSError
-    /// - Parameters:
-    ///   - errorType: DNS error type
-    ///   - reason: String describing reason for error
-    public init(_ errorType: DNSServiceErrorType, reason: String) {
-        self.errorType = errorType
-        self.reason = reason
-    }
+/// Enum containing all the DNS errors
+public enum NWDNSError: Error {
+    case noError
+    case unknown /* 0xFFFE FFFF */
+    case noSuchName
+    case noMemory
+    case badParam
+    case badReference
+    case badState
+    case badFlags
+    case unsupported
+    case notInitialized
+    case alreadyRegistered
+    case nameConflict
+    case invalid
+    case firewall
+    case incompatible /* client library incompatible with daemon */
+    case badInterfaceIndex
+    case refused
+    case noSuchRecord
+    case noAuth
+    case noSuchKey
+    case NATTraversal
+    case doubleNAT
+    case badTime /* Codes up to here existed in Tiger */
+    case badSig
+    case badKey
+    case transient
+    case serviceNotRunning /* Background daemon not running */
+    case NATPortMappingUnsupported /* NAT doesn't support PCP, NAT-PMP or UPnP */
+    case NATPortMappingDisabled /* NAT supports PCP, NAT-PMP or UPnP, but it's disabled by the administrator */
+    case noRouter /* No router currently configured (probably no network connectivity) */
+    case pollingMode
+    case timeout
+    case defunctConnection /* Connection to daemon returned a SO_ISDEFUNCT error result */
+    case other(DNSServiceErrorType)
 }
 
-extension NWDNSError: CustomStringConvertible {
-    public var description: String { return reason }
+extension NWDNSError {
+    /// Initialize NWDNSError from DNSServiceErrorType
+    /// - Parameter error: error type
+    public init(from error: DNSServiceErrorType) {
+        let errorInt = Int(error)
+        switch (errorInt) {
+        case kDNSServiceErr_NoError: self = .noError
+        case kDNSServiceErr_Unknown: self = .unknown
+        case kDNSServiceErr_NoSuchName: self = .noSuchName
+        case kDNSServiceErr_NoMemory: self = .noMemory
+        case kDNSServiceErr_BadParam: self = .badParam
+        case kDNSServiceErr_BadReference: self = .badReference
+        case kDNSServiceErr_BadState: self = .badState
+        case kDNSServiceErr_BadFlags: self = .badFlags
+        case kDNSServiceErr_Unsupported: self = .unsupported
+        case kDNSServiceErr_NotInitialized: self = .notInitialized
+        case kDNSServiceErr_AlreadyRegistered: self = .alreadyRegistered
+        case kDNSServiceErr_NameConflict: self = .nameConflict
+        case kDNSServiceErr_Invalid: self = .invalid
+        case kDNSServiceErr_Firewall: self = .firewall
+        case kDNSServiceErr_Incompatible: self = .incompatible
+        case kDNSServiceErr_BadInterfaceIndex: self = .badInterfaceIndex
+        case kDNSServiceErr_Refused: self = .refused
+        case kDNSServiceErr_NoSuchRecord: self = .noSuchRecord
+        case kDNSServiceErr_NoAuth: self = .noAuth
+        case kDNSServiceErr_NoSuchKey: self = .noSuchKey
+        case kDNSServiceErr_NATTraversal: self = .NATTraversal
+        case kDNSServiceErr_DoubleNAT: self = .doubleNAT
+        case kDNSServiceErr_BadTime: self = .badTime
+        case kDNSServiceErr_BadSig: self = .badSig
+        case kDNSServiceErr_BadKey: self = .badKey
+        case kDNSServiceErr_Transient: self = .transient
+        case kDNSServiceErr_ServiceNotRunning: self = .serviceNotRunning
+        case kDNSServiceErr_NATPortMappingUnsupported: self = .NATPortMappingUnsupported
+        case kDNSServiceErr_NATPortMappingDisabled: self = .NATPortMappingDisabled
+        case kDNSServiceErr_NoRouter: self = .noRouter
+        case kDNSServiceErr_PollingMode: self = .pollingMode
+        case kDNSServiceErr_Timeout: self = .timeout
+        case kDNSServiceErr_DefunctConnection: self = .defunctConnection
+        default:
+            self = .other(error)
+        }
+    }
 }
 
 public struct NWPOSIXError: Error {
@@ -98,7 +159,7 @@ class NWErrorHandler: ChannelInboundHandler {
         if let error = error as? NWError {
             switch error {
             case .dns(let errorType):
-                return NWDNSError(errorType, reason: error.localizedDescription)
+                return NWDNSError(from: errorType)
             case .tls(let status):
                 return NWTLSError(status, reason: error.localizedDescription)
             case .posix(let errorCode):

Tests/AsyncHTTPClientTests/HTTPClientNIOTSTests.swift

@@ -57,10 +57,9 @@ class HTTPClientNIOTSTests: XCTestCase {
         do {
             _ = try httpClient.get(url: "http://dnsfail/").wait()
             XCTFail("This should have failed")
-        } catch let error as NWDNSError {
-            XCTAssertEqual(error.errorType, DNSServiceErrorType(kDNSServiceErr_NoSuchRecord))
+        } catch NWDNSError.noSuchRecord {
         } catch {
-            XCTFail("Error should have been NWDSNError not \(type(of:error))")
+            XCTFail("Error should have been NWDSNError.noSuchRecord not \(error)")
         }
     }