Fix Evergreen failures on replica sets and against serverless (#743)

Author: kmahar

Tests/MongoSwiftSyncTests/MongoCursorTests.swift

@@ -56,6 +56,113 @@ final class MongoCursorTests: MongoSwiftTestCase {
         }
     }
 
+    func testNext() throws {
+        try self.withTestNamespace { _, _, coll in
+            // query empty collection
+            var cursor = try coll.find()
+            expect(cursor.next()).to(beNil())
+
+            // insert a doc so something matches initial query
+            try coll.insertOne(doc1)
+            cursor = try coll.find()
+
+            // next() returns a Result<Document, Error>?
+            let result = cursor.next()
+            expect(result).toNot(beNil())
+            expect(try result?.get()).to(equal(doc1))
+
+            expect(cursor.next()).to(beNil())
+            expect(cursor.isAlive()).to(beFalse())
+
+            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
+        }
+    }
+
+    func testKill() throws {
+        try self.withTestNamespace { _, _, coll in
+            _ = try coll.insertMany([[:], [:], [:]])
+            let cursor = try coll.find()
+            expect(cursor.isAlive()).to(beTrue())
+
+            expect(cursor.next()).toNot(beNil())
+            expect(cursor.isAlive()).to(beTrue())
+
+            cursor.kill()
+            expect(cursor.isAlive()).to(beFalse())
+            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
+        }
+    }
+
+    func testLazySequence() throws {
+        // Verify that the sequence behavior of normal cursors is as expected.
+        try self.withTestNamespace { _, _, coll in
+            try coll.insertMany([["_id": 1], ["_id": 2], ["_id": 3]])
+
+            var cursor = try coll.find()
+            expect(Array(cursor).count).to(equal(3))
+            expect(cursor.isAlive()).to(beFalse())
+
+            cursor = try coll.find()
+            let mapped = Array(cursor.map { _ in 1 })
+            expect(mapped).to(equal([1, 1, 1]))
+            expect(cursor.isAlive()).to(beFalse())
+
+            cursor = try coll.find()
+            let filteredMapped = cursor.filter {
+                $0.isSuccess
+            }.map { result -> Int? in
+                let document = try! result.get() // always succeeds due to filter stage
+                return document["_id"]?.toInt()
+            }
+            expect(Array(filteredMapped)).to(equal([1, 2, 3]))
+        }
+    }
+
+    func testCursorTerminatesOnError() throws {
+        try self.withTestNamespace { client, _, coll in
+            guard try client.supportsFailCommand() else {
+                printSkipMessage(testName: self.name, reason: "failCommand not supported")
+                return
+            }
+
+            try coll.insertOne([:])
+            try coll.insertOne([:])
+
+            let cursor = try coll.find([:], options: FindOptions(batchSize: 1))
+
+            let fp = FailPoint.failCommand(failCommands: ["getMore"], mode: .times(1), errorCode: 10)
+            try fp.enable()
+            defer { fp.disable() }
+
+            var count = 0
+            for result in cursor {
+                expect(count).to(beLessThan(2))
+                if count >= 2 {
+                    break
+                }
+                // getmore should return error
+                if count == 1 {
+                    expect(try result.get()).to(throwError())
+                    if result.isSuccess { break }
+                }
+                count += 1
+            }
+        }
+    }
+
+    func testCursorClosedError() throws {
+        try self.withTestNamespace { _, _, coll in
+            let cursor = try coll.find([:], options: FindOptions(batchSize: 1))
+
+            for _ in cursor {}
+            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
+        }
+    }
+}
+
+/// These are in their own test class to make it easier to skip running them against serverless, which does not support
+/// capped collections. (CLOUDP-106443)
+final class TailableCursorTests: MongoSwiftTestCase {
     func testTailableCursor() throws {
         let collOptions = CreateCollectionOptions(capped: true, max: 3, size: 1000)
         try self.withTestNamespace(collectionOptions: collOptions) { _, _, coll in
@@ -113,43 +220,6 @@ final class MongoCursorTests: MongoSwiftTestCase {
         }
     }
 
-    func testNext() throws {
-        try self.withTestNamespace { _, _, coll in
-            // query empty collection
-            var cursor = try coll.find()
-            expect(cursor.next()).to(beNil())
-
-            // insert a doc so something matches initial query
-            try coll.insertOne(doc1)
-            cursor = try coll.find()
-
-            // next() returns a Result<Document, Error>?
-            let result = cursor.next()
-            expect(result).toNot(beNil())
-            expect(try result?.get()).to(equal(doc1))
-
-            expect(cursor.next()).to(beNil())
-            expect(cursor.isAlive()).to(beFalse())
-
-            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
-        }
-    }
-
-    func testKill() throws {
-        try self.withTestNamespace { _, _, coll in
-            _ = try coll.insertMany([[:], [:], [:]])
-            let cursor = try coll.find()
-            expect(cursor.isAlive()).to(beTrue())
-
-            expect(cursor.next()).toNot(beNil())
-            expect(cursor.isAlive()).to(beTrue())
-
-            cursor.kill()
-            expect(cursor.isAlive()).to(beFalse())
-            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
-        }
-    }
-
     func testKillTailable() throws {
         let options = CreateCollectionOptions(capped: true, max: 3, size: 1000)
         try self.withTestNamespace(ns: self.getNamespace(suffix: "tail"), collectionOptions: options) { _, _, coll in
@@ -188,30 +258,7 @@ final class MongoCursorTests: MongoSwiftTestCase {
         }
     }
 
-    func testLazySequence() throws {
-        // Verify that the sequence behavior of normal cursors is as expected.
-        try self.withTestNamespace { _, _, coll in
-            try coll.insertMany([["_id": 1], ["_id": 2], ["_id": 3]])
-
-            var cursor = try coll.find()
-            expect(Array(cursor).count).to(equal(3))
-            expect(cursor.isAlive()).to(beFalse())
-
-            cursor = try coll.find()
-            let mapped = Array(cursor.map { _ in 1 })
-            expect(mapped).to(equal([1, 1, 1]))
-            expect(cursor.isAlive()).to(beFalse())
-
-            cursor = try coll.find()
-            let filteredMapped = cursor.filter {
-                $0.isSuccess
-            }.map { result -> Int? in
-                let document = try! result.get() // always succeeds due to filter stage
-                return document["_id"]?.toInt()
-            }
-            expect(Array(filteredMapped)).to(equal([1, 2, 3]))
-        }
-
+    func testLazySequenceTailableCursor() throws {
         // Verify that map/filter are lazy by using a tailable cursor.
         let options = CreateCollectionOptions(capped: true, max: 3, size: 10000)
         try self.withTestNamespace(collectionOptions: options) { _, _, coll in
@@ -239,45 +286,4 @@ final class MongoCursorTests: MongoSwiftTestCase {
             expect(cursor.isAlive()).to(beFalse())
         }
     }
-
-    func testCursorTerminatesOnError() throws {
-        try self.withTestNamespace { client, _, coll in
-            guard try client.supportsFailCommand() else {
-                printSkipMessage(testName: self.name, reason: "failCommand not supported")
-                return
-            }
-
-            try coll.insertOne([:])
-            try coll.insertOne([:])
-
-            let cursor = try coll.find([:], options: FindOptions(batchSize: 1))
-
-            let fp = FailPoint.failCommand(failCommands: ["getMore"], mode: .times(1), errorCode: 10)
-            try fp.enable()
-            defer { fp.disable() }
-
-            var count = 0
-            for result in cursor {
-                expect(count).to(beLessThan(2))
-                if count >= 2 {
-                    break
-                }
-                // getmore should return error
-                if count == 1 {
-                    expect(try result.get()).to(throwError())
-                    if result.isSuccess { break }
-                }
-                count += 1
-            }
-        }
-    }
-
-    func testCursorClosedError() throws {
-        try self.withTestNamespace { _, _, coll in
-            let cursor = try coll.find([:], options: FindOptions(batchSize: 1))
-
-            for _ in cursor {}
-            expect(try cursor.next()?.get()).to(throwError(errorType: MongoError.LogicError.self))
-        }
-    }
 }

Tests/MongoSwiftSyncTests/SDAMTests.swift

@@ -236,8 +236,9 @@ final class SDAMTests: MongoSwiftTestCase {
             } + // true in URI
             hostURIs.map { try MongoClient.makeTestClient($0, options: optsTrue) } // true in options struct
 
-        // 4 of 6 attempts to perform writes should fail assuming these are 3-node replica sets, since in 2 cases we
-        // will directly connect to the primary, and in the other 4 we will directly connect to a secondary.
+        // we test against 3-node replica sets with one primary, one secondary, and one arbiter. 4 of 6 attempts to
+        // perform writes here should fail, since in 2 cases we directly connect to the primary, and in the other 4 we
+        // will directly connect to the secondary or arbiter.
 
         var failures = 0
         for client in testClientsShouldMostlyFail {
@@ -246,14 +247,17 @@ final class SDAMTests: MongoSwiftTestCase {
                     try collection.insertOne(["x": 1])
                 }
             } catch {
-                expect(error).to(beAnInstanceOf(MongoError.CommandError.self))
+                // the error type here can vary. when the deployment does not use auth, the error should be a
+                // CommandError. when the deployment does use auth, a write against a secondary will throw a
+                // CommandError but a write against the arbiter will throw an AuthenticationError as arbiters do not
+                // support auth.
                 failures += 1
             }
         }
 
         expect(failures).to(
             equal(4),
-            description: "Writes should fail when connecting to secondaries with directConnection=true"
+            description: "Writes should fail when connecting to secondaries and arbiters with directConnection=true"
         )
     }
 }