SWIFT-1407 / SWIFT-1174 ipv4 address and UNIX domain socket support (#711)

Author: isabelatkinson

Sources/MongoSwift/MongoConnectionString.swift

@@ -92,7 +92,7 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
             return port
         }
 
-        private enum HostType: String {
+        internal enum HostType: String {
             case ipv4
             case ipLiteral = "ip_literal"
             case hostname
@@ -105,7 +105,7 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
         /// The port number.
         public let port: UInt16?
 
-        private let type: HostType
+        internal let type: HostType
 
         /// Initializes a ServerAddress, using the default localhost:27017 if a host/port is not provided.
         internal init(_ hostAndPort: String = "localhost:27017") throws {
@@ -114,7 +114,6 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
             }
 
             // Check if host is an IPv6 literal.
-            // TODO: SWIFT-1407: support IPv4 address parsing.
             if hostAndPort.first == "[" {
                 let ipLiteralRegex = try NSRegularExpression(pattern: #"^\[(.*)\](?::([0-9]+))?$"#)
                 guard
@@ -135,18 +134,29 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
                 self.type = .ipLiteral
             } else {
                 let parts = hostAndPort.components(separatedBy: ":")
-                self.host = String(parts[0])
                 guard parts.count <= 2 else {
                     throw MongoError.InvalidArgumentError(
                         message: "expected only a single port delimiter ':' in \(hostAndPort)"
                     )
                 }
+
+                let host = parts[0]
+                if host.hasSuffix(".sock") {
+                    self.host = try host.getPercentDecoded(forKey: "UNIX domain socket")
+                    self.type = .unixDomainSocket
+                } else if host.isIPv4() {
+                    self.host = host
+                    self.type = .ipv4
+                } else {
+                    self.host = try host.getPercentDecoded(forKey: "hostname")
+                    self.type = .hostname
+                }
+
                 if parts.count > 1 {
                     self.port = try HostIdentifier.parsePort(from: parts[1])
                 } else {
                     self.port = nil
                 }
-                self.type = .hostname
             }
         }
 
@@ -420,7 +430,6 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
             throw MongoError.InvalidArgumentError(message: "Invalid connection string")
         }
         let identifiersAndOptions = schemeAndRest[1].components(separatedBy: "/")
-        // TODO: SWIFT-1174: handle unescaped slashes in unix domain sockets.
         guard identifiersAndOptions.count <= 2 else {
             throw MongoError.InvalidArgumentError(
                 message: "Connection string contains an unescaped slash"
@@ -484,6 +493,9 @@ public struct MongoConnectionString: Codable, LosslessStringConvertible {
             self.defaultAuthDB = decoded
             // If no other authentication options were provided, we should use the defaultAuthDB as the credential
             // source. This will be overwritten later if an authSource is provided.
+            if self.credential == nil {
+                self.credential = MongoCredential()
+            }
             self.credential?.source = decoded
         }
 
@@ -1033,6 +1045,19 @@ extension StringProtocol {
         return decoded
     }
 
+    fileprivate func isIPv4() -> Bool {
+        let numbers = self.components(separatedBy: ".")
+        guard numbers.count == 4 else {
+            return false
+        }
+        for number in numbers {
+            guard let n = Int(number), (0...255).contains(n) else {
+                return false
+            }
+        }
+        return true
+    }
+
     fileprivate func getValidatedUserInfo(forKey key: String) throws -> String {
         for character in MongoConnectionString.forbiddenUserInfoCharacters {
             if self.contains(character) {

Tests/MongoSwiftTests/ConnectionStringTests.swift

@@ -81,15 +81,6 @@ let skipUnsupported: [String: [String]] = [
     "valid-options.json": ["option names are normalized to lowercase"] // we don't support MONGODB-CR authentication
 ]
 
-// Tests for options that are not yet supported on MongoConnectionString.
-// TODO: delete this when MongoConnectionString is fully implemented
-let skipMongoConnectionStringUnsupported: [String: [String]] = [
-    // TODO: SWIFT-1174: unskip these tests
-    "valid-db-with-dotted-name.json": ["*"],
-    "valid-unix_socket-absolute.json": ["*"],
-    "valid-unix_socket-relative.json": ["*"]
-]
-
 func shouldSkip(file: String, test: String) -> Bool {
     if let skipList = skipUnsupported[file],
        skipList.contains(where: test.lowercased().contains) || skipList.contains("*")
@@ -100,24 +91,12 @@ func shouldSkip(file: String, test: String) -> Bool {
     return false
 }
 
-func shouldSkipMongoConnectionString(file: String, test: String) -> Bool {
-    if let skipList = skipMongoConnectionStringUnsupported[file],
-       skipList.contains(where: test.lowercased().contains) || skipList.contains("*")
-    {
-        return true
-    }
-
-    return false
-}
-
 final class ConnectionStringTests: MongoSwiftTestCase {
     func runTests(_ specName: String) throws {
         let testFiles = try retrieveSpecTestFiles(specName: specName, asType: ConnectionStringTestFile.self)
         for (filename, file) in testFiles {
             for testCase in file.tests {
-                guard !shouldSkip(file: filename, test: testCase.description)
-                    && !shouldSkipMongoConnectionString(file: filename, test: testCase.description)
-                else {
+                guard !shouldSkip(file: filename, test: testCase.description) else {
                     continue
                 }
 
@@ -602,4 +581,31 @@ final class ConnectionStringTests: MongoSwiftTestCase {
         expect(try ConnectionString("mongodb://localhost:27017/?directConnection=true", options: opts))
             .to(throwError(errorType: MongoError.InvalidArgumentError.self))
     }
+
+    func testIPv4AddressParsing() throws {
+        // valid IPv4
+        let connString1 = try MongoConnectionString(throwsIfInvalid: "mongodb://1.2.3.4")
+        guard let host = connString1.hosts.first else {
+            XCTFail("connection string should contain one host")
+            return
+        }
+        expect(host.host).to(equal("1.2.3.4"))
+        expect(host.type).to(equal(.ipv4))
+        // invalid IPv4 should fall back to hostname (only three numbers)
+        let connString2 = try MongoConnectionString(throwsIfInvalid: "mongodb://1.2.3")
+        guard let host = connString2.hosts.first else {
+            XCTFail("connection string should contain one host")
+            return
+        }
+        expect(host.host).to(equal("1.2.3"))
+        expect(host.type).to(equal(.hostname))
+        // invalid IPv4 should fall back to hostname (numbers out of bounds)
+        let connString3 = try MongoConnectionString(throwsIfInvalid: "mongodb://256.1.2.3")
+        guard let host = connString3.hosts.first else {
+            XCTFail("connection string should contain one host")
+            return
+        }
+        expect(host.host).to(equal("256.1.2.3"))
+        expect(host.type).to(equal(.hostname))
+    }
 }