SWIFT-1383 Test that driver only creates implicit session after connection checkout (#734)

Author: kmahar

.evergreen/config.yml

@@ -1399,7 +1399,7 @@ buildvariants:
   display_name: "${sanitize} ${os-fully-featured} ${ssl-auth}"
   matrix_spec:
     os-fully-featured: "ubuntu-18.04"
-    swift-version: "5.5"
+    swift-version: "5.4" # TODO SWIFT-1499: update to Swift 5.5
     ssl-auth: "*"
     sanitize: "tsan"
   tasks:

Tests/MongoSwiftSyncTests/ClientSessionTests.swift

@@ -320,6 +320,8 @@ final class SyncClientSessionTests: MongoSwiftTestCase {
         }
     }
 
+    /// Sessions spec test 13 was easier to write with concurrency and lives in MongoSwiftTests/AsyncAwaitTests.swift.
+
     /// Test that causal consistency guarantees are met on deployments that support cluster time.
     func testCausalConsistency() throws {
         guard MongoSwiftTestCase.topologyType != .single else {
@@ -512,17 +514,6 @@ final class SyncClientSessionTests: MongoSwiftTestCase {
             expect(startedEvents).to(haveCount(1))
             expect(startedEvents[0].command["readConcern"]?.documentValue?["afterClusterTime"]).to(beNil())
         }
-
-        // Causal consistency spec test 10: When an unacknowledged write is executed in a causally consistent
-        // ClientSession the operationTime property of the ClientSession is not updated
-        try client.withSession(options: ClientSessionOptions(causalConsistency: true)) { session in
-            let collection1 = db.collection(
-                self.getCollectionName(),
-                options: MongoCollectionOptions(writeConcern: try WriteConcern(w: .number(0)))
-            )
-            try collection1.insertOne(["x": 3])
-            expect(session.operationTime).to(beNil())
-        }
     }
 
     func testSessionsUnified() throws {

Tests/MongoSwiftTests/AsyncAwaitTestUtils.swift

@@ -70,14 +70,15 @@ extension MongoSwiftTestCase {
     // see: https://github.com/realm/SwiftLint/issues/3753
     internal func withTestNamespace<T>(
         ns: MongoNamespace? = nil,
+        clientOptions: MongoClientOptions? = nil,
         collectionOptions: CreateCollectionOptions? = nil,
         _ f: (MongoClient, MongoDatabase, MongoCollection<BSONDocument>) async throws -> T
     ) async throws -> T {
         let ns = ns ?? self.getNamespace()
         guard let collName = ns.collection else {
             throw TestError(message: "missing collection")
         }
-        return try await self.withTestClient { client in
+        return try await self.withTestClient(options: clientOptions) { client in
             let database = client.db(ns.db)
             let collection: MongoCollection<BSONDocument>
             do {
@@ -147,4 +148,14 @@ extension MongoClient {
     }
 }
 
+@available(macOS 12, *)
+extension TestCommandMonitor {
+    /// Capture events that occur while the the provided closure executes.
+    public func captureEvents<T>(_ f: () async throws -> T) async rethrows -> T {
+        self.enable()
+        defer { self.disable() }
+        return try await f()
+    }
+}
+
 #endif

Tests/MongoSwiftTests/AsyncAwaitTests.swift

@@ -144,6 +144,55 @@ final class AsyncAwaitTests: MongoSwiftTestCase {
             }
         }
     }
+
+    /// Sessions prose test 13: Test that implicit sessions only allocate their server session after a successful
+    /// connection checkout.
+    func testImplicitSessionsCreatedAfterConnectionCheckout() throws {
+        testAsync {
+            let clientOptions = MongoClientOptions(maxPoolSize: 1)
+            try await self.withTestNamespace(clientOptions: clientOptions) { client, _, coll in
+                let monitor = client.addCommandMonitor()
+                try await monitor.captureEvents {
+                    async let insert = try coll.insertOne(["x": 1])
+                    async let delete = try coll.deleteOne(["x": 2])
+                    async let update = try coll.updateOne(filter: ["x": 3], update: ["$set": ["y": 1]])
+                    async let bulk = try coll.bulkWrite([.updateOne(filter: ["x": 4], update: ["$set": ["y": 1]])])
+                    async let findOneAndDelete = try coll.findOneAndDelete(["x": 5])
+                    async let findOneAndUpdate = try coll.findOneAndUpdate(
+                        filter: ["x": 6],
+                        update: ["$set": ["y": 1]]
+                    )
+                    async let findOneAndReplace = try coll.findOneAndReplace(filter: ["x": 7], replacement: ["x": 8])
+                    async let cursor = try coll.find()
+                    // the cursor will hold onto its connection until its done being iterated, so we need to iterate to
+                    // allow the other operations to make progress.
+                    for try await _ in try await cursor {}
+                    _ = try await [
+                        insert,
+                        delete,
+                        update,
+                        bulk,
+                        findOneAndDelete,
+                        findOneAndUpdate,
+                        findOneAndReplace
+                    ] as [Any?]
+                }
+                let events = monitor.events(withEventTypes: [.commandStartedEvent])
+                guard events.count == 8 else {
+                    XCTFail("Expected 8 command started events, but only found \(events.count)")
+                    return
+                }
+                let lsids = events.compactMap { $0.commandStartedValue!.command["lsid"] }
+                guard lsids.count == 8 else {
+                    XCTFail("Expected 8 command started events to contain lsids, but only found \(lsids.count)")
+                    return
+                }
+                for i in 1...7 {
+                    expect(lsids[i]).to(equal(lsids[0]))
+                }
+            }
+        }
+    }
 }
 
 @available(macOS 12, *)