fix(minor): [sc-32833] Add possibility to construct Consul instance with address string.

Sources/ConsulServiceDiscovery/Consul.swift

@@ -10,6 +10,9 @@
     case httpResponseError(HTTPResponseStatus, String?)
     case failedToDecodeValue(String)
     case error(String)
+    case emptyHost
+    case invalidPort(String)
+    case portOutOfRange(String)
 }
 
 protocol ConsulResponseHandler: Sendable {
@@ -357,7 +360,7 @@
                         let values = try buffer.withUnsafeReadableBytes {
                             try JSONDecoder().decode([Value].self, from: Data($0))
                         }
                         if values.count > 0 {
                             let value = values[0]
                             if let valueValue = value.value {
                                 if let data = Data(base64Encoded: valueValue), let str = String(data: data, encoding: .utf8) {
@@ -848,7 +851,7 @@
         }
     }
 
-    public init(host: String? = nil, port: Int? = nil, logLevel: Logger.Level = .info) {
+    public init(host: String, port: Int, logLevel: Logger.Level = .info) {
         // We use EventLoopFuture<> as a result for most calls,
         // the problem here is the 'future' is tied to particular event loop,
         // and from SwiftNIO point of view it is an error if we fill the 'future'
@@ -858,8 +861,6 @@
         // The only way to workaround that issue now is to use an event loop group
         // with only one event loop.
         let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        let host = host ?? Self.defaultHost
-        let port = port ?? Self.defaultPort
         impl = Impl(host, port, logLevel, eventLoopGroup)
         agent = AgentEndpoint(impl)
         catalog = CatalogEndpoint(impl)
@@ -869,6 +870,44 @@
         status = StatusEndpoint(impl)
     }
 
+    convenience public init(host: String? = nil, port: Int? = nil, logLevel: Logger.Level = .info) {
+        self.init(
+            host: host ?? Self.defaultHost,
+            port: port ?? Self.defaultPort,
+            logLevel: logLevel
+        )
+    }
+
+    static func parseAddress(_ address: String?) throws -> (host: String, port: Int) {
+        if let address, !address.isEmpty {
+            guard let colon = address.lastIndex(of: ":") else {
+                return (address, Self.defaultPort)
+            }
+
+            let host = String(address[..<colon])
+            if host.isEmpty {
+                throw ConsulError.emptyHost
+            }
+
+            let str = address[address.index(after: colon)...]
+            guard let port = Int(str) else {
+                throw ConsulError.invalidPort(String(str))
+            }
+            guard (0...65535).contains(port) else {
+                throw ConsulError.portOutOfRange(String(str))
+            }
+
+            return (host, port)
+        } else {
+            return (Self.defaultHost, Self.defaultPort)
+        }
+    }
+
+    convenience public init(address: String?, logLevel: Logger.Level = .info) throws {
+        let (host, port) = try Self.parseAddress(address)
+        self.init(host: host, port: port, logLevel: logLevel)
+    }
+
     public func syncShutdown() throws {
         try impl.eventLoopGroup.syncShutdownGracefully()
     }
@@ -993,4 +1032,4 @@
         }
         context.close(promise: nil)
     }
 }

Tests/ConsulServiceDiscoveryTests/ConsulTests.swift

@@ -1,6 +1,6 @@
 @testable import ConsulServiceDiscovery
 import NIOPosix
 import class NIOCore.EventLoopFuture
 import XCTest
 
 final class ConsulTests: XCTestCase {
@@ -145,7 +145,7 @@
         let testKey = "test-key-does-not-exist"
         let future = consul.kv.valueForKey(testKey)
         let value = try future.wait()
-        XCTAssertEqual(value, nil)
+        XCTAssertNil(value)
         try consul.syncShutdown()
     }
 
@@ -153,12 +153,12 @@
         let pid = ProcessInfo.processInfo.processIdentifier
         let consul = Consul()
 
         let session1 = Session(lockDelay: 1*1_000_000_000, ttl: "10s")
         let session1Future = consul.session.create(session1)
         let session1Id = try session1Future.wait()
         // print("session1=\(session1Id)")
 
         let session2 = Session(lockDelay: 1*1_000_000_000, ttl: "10s")
         let session2Future = consul.session.create(session2)
         let session2Id = try session2Future.wait()
         // print("session2=\(session2Id)")
@@ -178,8 +178,59 @@
 
         let renewFuture = consul.session.renew(session1Id)
         let renewResult = try renewFuture.wait()
-        //print("\(renewResult)")
+        // print("\(renewResult)")
         XCTAssertEqual(renewResult.lockDelay!.ns, 1_000_000_000)
         XCTAssertEqual(renewResult.ttl, "10s")
     }
+
+    func testParseAddress() throws {
+        var (host, port): (String, Int)
+
+        (host, port) = try Consul.parseAddress(nil)
+        XCTAssertEqual(host, Consul.defaultHost)
+        XCTAssertEqual(port, Consul.defaultPort)
+
+        (host, port) = try Consul.parseAddress("")
+        XCTAssertEqual(host, Consul.defaultHost)
+        XCTAssertEqual(port, Consul.defaultPort)
+
+        (host, port) = try Consul.parseAddress("localhost")
+        XCTAssertEqual(host, "localhost")
+        XCTAssertEqual(port, Consul.defaultPort)
+
+        (host, port) = try Consul.parseAddress("localhost:12345")
+        XCTAssertEqual(host, "localhost")
+        XCTAssertEqual(port, 12_345)
+
+        XCTAssertThrowsError(try Consul.parseAddress(":8500")) { error in
+            guard let error = error as? ConsulError, case .emptyHost = error else {
+                XCTFail("expected ConsulError.emptyHost, got \(error)")
+                return
+            }
+        }
+
+        XCTAssertThrowsError(try Consul.parseAddress("localhost:")) { error in
+            guard let error = error as? ConsulError, case let .invalidPort(value) = error else {
+                XCTFail("expected ConsulError.invalidPort, got \(error)")
+                return
+            }
+            XCTAssertEqual(value, "")
+        }
+
+        XCTAssertThrowsError(try Consul.parseAddress("localhost:abc")) { error in
+            guard let error = error as? ConsulError, case let .invalidPort(value) = error else {
+                XCTFail("expected ConsulError.invalidPort, got \(error)")
+                return
+            }
+            XCTAssertEqual(value, "abc")
+        }
+
+        XCTAssertThrowsError(try Consul.parseAddress("localhost:999999")) { error in
+            guard let error = error as? ConsulError, case let .portOutOfRange(value) = error else {
+                XCTFail("expected ConsulError.portOutOfRange, got \(error)")
+                return
+            }
+            XCTAssertEqual(value, "999999")
+        }
+    }
 }