SWIFT-1309, SWIFT-1318, SWIFT-1241, SWIFT-1323, SWIFT-1324 Support testing against a load balancer locally (#666)

Author: kmahar

Sources/CLibMongoC/include/CLibMongoC_mongoc-server-description.h

@@ -66,6 +66,12 @@ MONGOC_EXPORT (int32_t)
 mongoc_server_description_compressor_id (
    const mongoc_server_description_t *description);
 
+/* mongoc_global_mock_service_id is only used for testing. The test runner sets
+ * this to true when testing against a load balanced deployment to mock the
+ * presence of a serviceId field in the "hello" response. The purpose of this is
+ * further described in the Load Balancer test README. */
+extern bool mongoc_global_mock_service_id;
+
 BSON_END_DECLS
 
 #endif

Sources/CLibMongoC/mongoc/mongoc-server-description-private.h

@@ -200,10 +200,4 @@ bool
 mongoc_server_description_has_service_id (
    const mongoc_server_description_t *description);
 
-/* mongoc_global_mock_service_id is only used for testing. The test runner sets
- * this to true when testing against a load balanced deployment to mock the
- * presence of a serviceId field in the "hello" response. The purpose of this is
- * further described in the Load Balancer test README. */
-extern bool mongoc_global_mock_service_id;
-
 #endif

Sources/MongoSwift/SDAM.swift

@@ -2,7 +2,7 @@ import CLibMongoC
 import Foundation
 
 /// A struct representing a network address, consisting of a host and port.
-public struct ServerAddress: Equatable {
+public struct ServerAddress: Equatable, Hashable {
     /// The hostname or IP address.
     public let host: String
 
@@ -67,25 +67,68 @@ private struct HelloResponse: Decodable {
 /// A struct describing a mongod or mongos process.
 public struct ServerDescription {
     /// The possible types for a server.
-    public enum ServerType: String, Equatable {
+    public struct ServerType: RawRepresentable, Equatable {
         /// A standalone mongod server.
-        case standalone = "Standalone"
+        public static let standalone = ServerType(.standalone)
+
         /// A router to a sharded cluster, i.e. a mongos server.
-        case mongos = "Mongos"
+        public static let mongos = ServerType(.mongos)
+
         /// A replica set member which is not yet checked, but another member thinks it is the primary.
-        case possiblePrimary = "PossiblePrimary"
+        public static let possiblePrimary = ServerType(.possiblePrimary)
+
         /// A replica set primary.
-        case rsPrimary = "RSPrimary"
+        public static let rsPrimary = ServerType(.rsPrimary)
+
         /// A replica set secondary.
-        case rsSecondary = "RSSecondary"
+        public static let rsSecondary = ServerType(.rsSecondary)
+
         /// A replica set arbiter.
-        case rsArbiter = "RSArbiter"
+        public static let rsArbiter = ServerType(.rsArbiter)
+
         /// A replica set member that is none of the other types (a passive, for example).
-        case rsOther = "RSOther"
+        public static let rsOther = ServerType(.rsOther)
+
         /// A replica set member that does not report a set name or a hosts list.
-        case rsGhost = "RSGhost"
+        public static let rsGhost = ServerType(.rsGhost)
+
         /// A server type that is not yet known.
-        case unknown = "Unknown"
+        public static let unknown = ServerType(.unknown)
+
+        /// A load balancer.
+        public static let loadBalancer = ServerType(.loadBalancer)
+
+        /// Internal representation of server type. If enums could be marked non-exhaustive in Swift, this would be the
+        /// public representation too.
+        private enum _ServerType: String, Equatable {
+            case standalone = "Standalone"
+            case mongos = "Mongos"
+            case possiblePrimary = "PossiblePrimary"
+            case rsPrimary = "RSPrimary"
+            case rsSecondary = "RSSecondary"
+            case rsArbiter = "RSArbiter"
+            case rsOther = "RSOther"
+            case rsGhost = "RSGhost"
+            case unknown = "Unknown"
+            case loadBalancer = "LoadBalancer"
+        }
+
+        private let _serverType: _ServerType
+
+        private init(_ _type: _ServerType) {
+            self._serverType = _type
+        }
+
+        public var rawValue: String {
+            self._serverType.rawValue
+        }
+
+        public init?(rawValue: String) {
+            guard let _type = _ServerType(rawValue: rawValue) else {
+                return nil
+            }
+            self._serverType = _type
+        }
     }
 
     /// The hostname or IP and the port number that the client connects to. Note that this is not the "me" field in the
@@ -206,17 +249,52 @@ extension ServerDescription: Equatable {
 /// which servers are up, what type of servers they are, which is primary, and so on.
 public struct TopologyDescription: Equatable {
     /// The possible types for a topology.
-    public enum TopologyType: String, Equatable {
+    public struct TopologyType: RawRepresentable, Equatable {
         /// A single mongod server.
-        case single = "Single"
+        public static let single = TopologyType(.single)
+
         /// A replica set with no primary.
-        case replicaSetNoPrimary = "ReplicaSetNoPrimary"
+        public static let replicaSetNoPrimary = TopologyType(.replicaSetNoPrimary)
+
         /// A replica set with a primary.
-        case replicaSetWithPrimary = "ReplicaSetWithPrimary"
+        public static let replicaSetWithPrimary = TopologyType(.replicaSetWithPrimary)
+
         /// Sharded topology.
-        case sharded = "Sharded"
+        public static let sharded = TopologyType(.sharded)
+
         /// A topology whose type is not yet known.
-        case unknown = "Unknown"
+        public static let unknown = TopologyType(.unknown)
+
+        /// A topology with a load balancer in front.
+        public static let loadBalanced = TopologyType(.loadBalanced)
+
+        /// Internal representation of topology type. If enums could be marked non-exhaustive in Swift, this would be
+        /// the public representation too.
+        private enum _TopologyType: String, Equatable {
+            case single = "Single"
+            case replicaSetNoPrimary = "ReplicaSetNoPrimary"
+            case replicaSetWithPrimary = "ReplicaSetWithPrimary"
+            case sharded = "Sharded"
+            case unknown = "Unknown"
+            case loadBalanced = "LoadBalanced"
+        }
+
+        private let _topologyType: _TopologyType
+
+        private init(_ _type: _TopologyType) {
+            self._topologyType = _type
+        }
+
+        public var rawValue: String {
+            self._topologyType.rawValue
+        }
+
+        public init?(rawValue: String) {
+            guard let _type = _TopologyType(rawValue: rawValue) else {
+                return nil
+            }
+            self._topologyType = _type
+        }
     }
 
     /// The type of this topology.

Sources/TestsCommon/CommonTestUtils.swift

@@ -42,18 +42,29 @@ open class MongoSwiftTestCase: XCTestCase {
     /// will return a default of "mongodb://127.0.0.1/". If singleMongos is true and this is a sharded topology, will
     /// edit $MONGODB_URI as needed so that it only contains a single host.
     public static func getConnectionString(singleMongos: Bool = true) -> ConnectionString {
-        // we only need to manipulate the URI if singleMongos is requested and the topology is sharded.
-        guard singleMongos && MongoSwiftTestCase.topologyType == .sharded else {
+        switch (MongoSwiftTestCase.topologyType, singleMongos) {
+        case (.sharded, true):
+            let hosts = self.getHosts()
+            var output = Self.uri
+            // remove all but the first host so we connect to a single mongos.
+            for host in hosts[1...] {
+                output.removeSubstring(",\(host.description)")
+            }
+            return try! ConnectionString(output)
+        case (.loadBalanced, true):
+            guard let uri = Self.singleMongosLoadBalancedURI else {
+                fatalError("Missing SINGLE_MONGOS_LB_URI environment variable")
+            }
+            return try! ConnectionString(uri)
+        case (.loadBalanced, false):
+            guard let uri = Self.multipleMongosLoadBalancedURI else {
+                fatalError("Missing MULTIPLE_MONGOS_LB_URI environment variable")
+            }
+            return try! ConnectionString(uri)
+        default:
+            // just return as-is.
             return try! ConnectionString(Self.uri)
         }
-
-        let hosts = self.getHosts()
-        var output = Self.uri
-        // remove all but the first host so we connect to a single mongos.
-        for host in hosts[1...] {
-            output.removeSubstring(",\(host.description)")
-        }
-        return try! ConnectionString(output)
     }
 
     /// Get a connection string for the specified host only.
@@ -116,6 +127,14 @@ open class MongoSwiftTestCase: XCTestCase {
         return uri
     }
 
+    public static var singleMongosLoadBalancedURI: String? {
+        ProcessInfo.processInfo.environment["SINGLE_MONGOS_LB_URI"]
+    }
+
+    public static var multipleMongosLoadBalancedURI: String? {
+        ProcessInfo.processInfo.environment["MULTIPLE_MONGOS_LB_URI"]
+    }
+
     /// Indicates that we are running the tests with SSL enabled, determined by the environment variable $SSL.
     public static var ssl: Bool {
         ProcessInfo.processInfo.environment["SSL"] == "ssl"
@@ -168,7 +187,7 @@ public enum TestTopologyConfiguration: String, Decodable {
     /// A standalone server.
     case single
     /// A load balancer.
-    case loadBalancer = "load-balanced"
+    case loadBalanced = "load-balanced"
 
     /// Returns a Bool indicating whether this topology is either sharded configuration.
     public var isSharded: Bool {
@@ -184,6 +203,9 @@ public enum TestTopologyConfiguration: String, Decodable {
             helloReply["isreplicaset"] != true
         {
             self = .single
+            // TODO: SWIFT-1319: eventually, we should be able to just check for serviceId here.
+        } else if MongoSwiftTestCase.topologyType == .loadBalanced {
+            self = .loadBalanced
         } else if helloReply["msg"] == "isdbgrid" {
             // Serverless proxy reports as a mongos but presents no shards
             guard !shards.isEmpty || MongoSwiftTestCase.serverless else {
@@ -509,6 +531,8 @@ extension TopologyDescription.TopologyType {
             self = .sharded
         case "replicaset", "replica_set":
             self = .replicaSetWithPrimary
+        case "loadbalanced", "load_balanced":
+            self = .loadBalanced
         default:
             self = .single
         }
@@ -680,3 +704,50 @@ extension InsertManyResult {
         InsertManyResult(from: result)
     }
 }
+
+// TODO: SWIFT-1319 Remove this method and usages of it.
+/// Sets the libmongoc global variable indicating whether to include mock serviceIds in hello responses to the
+/// provided value. This is necessary for load balancer testing until SERVER-58500 is complete.
+public func setMockServiceId(to value: Bool) {
+    mongoc_global_mock_service_id = value
+}
+
+/// Resolves programmatically provided client options with those specified via environment variables.
+public func resolveClientOptions(_ options: MongoClientOptions? = nil) -> MongoClientOptions {
+    var opts = options ?? MongoClientOptions()
+    // if SSL is on and custom TLS options were not provided, enable them
+    if MongoSwiftTestCase.ssl {
+        opts.tls = true
+        if let caPath = MongoSwiftTestCase.sslCAFilePath {
+            opts.tlsCAFile = URL(string: caPath)
+        }
+        if let certPath = MongoSwiftTestCase.sslPEMKeyFilePath {
+            opts.tlsCertificateKeyFile = URL(string: certPath)
+        }
+    }
+    if let apiVersion = MongoSwiftTestCase.apiVersion {
+        if opts.serverAPI == nil {
+            opts.serverAPI = MongoServerAPI(version: apiVersion)
+        } else {
+            opts.serverAPI!.version = apiVersion
+        }
+    }
+
+    if MongoSwiftTestCase.auth {
+        if let scramUser = MongoSwiftTestCase.scramUser, let scramPass = MongoSwiftTestCase.scramPassword {
+            opts.credential = MongoCredential(username: scramUser, password: scramPass)
+        }
+    }
+
+    // serverless tests are required to use compression.
+    if MongoSwiftTestCase.serverless {
+        opts.compressors = [.zlib]
+    }
+
+    // TODO: SWIFT-1319 Remove this.
+    if MongoSwiftTestCase.topologyType == .loadBalanced {
+        setMockServiceId(to: true)
+    }
+
+    return opts
+}