CSHARP-2569: Require retryable writes network error tests to run on mongos 4.2+.

Author: DmitryLukyanov

tests/MongoDB.Driver.Tests/Specifications/retryable-writes/BulkWriteTest.cs

@@ -65,7 +65,12 @@ protected override void ExecuteSync(IMongoCollection<BsonDocument> collection)
 
         protected override void VerifyResult(BsonDocument result)
         {
-            var expectedResult = ParseResult(result);
+            var expectedResult = ParseResult(result, out var expectedInsertedIds);
+            foreach (var insertedId in expectedInsertedIds)
+            {
+                var insertModel = (InsertOneModel<BsonDocument>)_result.ProcessedRequests[insertedId.Key];
+                insertModel.Document["_id"].Should().Be(insertedId.Value);
+            }
             _result.DeletedCount.Should().Be(expectedResult.DeletedCount);
             _result.InsertedCount.Should().Be(expectedResult.InsertedCount);
             _result.MatchedCount.Should().Be(expectedResult.MatchedCount);
@@ -180,12 +185,15 @@ private BulkWriteOptions ParseOptions(BsonDocument options)
             return result;
         }
 
-        private BulkWriteResult<BsonDocument> ParseResult(BsonDocument result)
+        private BulkWriteResult<BsonDocument> ParseResult(BsonDocument result, out Dictionary<int, int> expectedInsertedIds)
         {
             VerifyFields(result, "deletedCount", "insertedCount", "insertedIds", "matchedCount", "modifiedCount", "upsertedCount", "upsertedIds");
 
             var deletedCount = result["deletedCount"].ToInt64();
-            var insertedCount = result["insertedIds"].AsBsonDocument.ElementCount; // TODO: anything to verify besides count?
+            var insertedCount = result["insertedCount"].ToInt64();
+            expectedInsertedIds = result["insertedIds"]
+                .AsBsonDocument
+                .ToDictionary(k => Convert.ToInt32(k.Name), v => v.Value.ToInt32());
             var matchedCount = result["matchedCount"].ToInt64();
             var modifiedCount = result["modifiedCount"].ToInt64();
             var processedRequests = new List<WriteModel<BsonDocument>>(_requests);

tests/MongoDB.Driver.Tests/Specifications/retryable-writes/DeleteManyTest.cs

@@ -0,0 +1,72 @@
+/* Copyright 2019-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using FluentAssertions;
+using MongoDB.Bson;
+
+namespace MongoDB.Driver.Tests.Specifications.retryable_writes
+{
+    public class DeleteManyTest : RetryableWriteTestBase
+    {
+        // private fields
+        private FilterDefinition<BsonDocument> _filter;
+        private DeleteResult _result;
+
+        // public methods
+        public override void Initialize(BsonDocument operation)
+        {
+            VerifyFields(operation, "name", "arguments");
+
+            foreach (var argument in operation["arguments"].AsBsonDocument)
+            {
+                switch (argument.Name)
+                {
+                    case "filter":
+                        _filter = argument.Value.AsBsonDocument;
+                        break;
+
+                    default:
+                        throw new ArgumentException($"Unexpected argument: {argument.Name}.");
+                }
+            }
+        }
+
+        // protected methods
+        protected override void ExecuteAsync(IMongoCollection<BsonDocument> collection)
+        {
+            _result = collection.DeleteManyAsync(_filter).GetAwaiter().GetResult();
+        }
+
+        protected override void ExecuteSync(IMongoCollection<BsonDocument> collection)
+        {
+            _result = collection.DeleteMany(_filter);
+        }
+
+        protected override void VerifyResult(BsonDocument result)
+        {
+            var expectedResult = ParseResult(result);
+            _result.DeletedCount.Should().Be(expectedResult.DeletedCount);
+        }
+
+        // private methods
+        private DeleteResult ParseResult(BsonDocument result)
+        {
+            VerifyFields(result, "deletedCount");
+            var deletedCount = result["deletedCount"].ToInt64();
+            return new DeleteResult.Acknowledged(deletedCount);
+        }
+    }
+}

tests/MongoDB.Driver.Tests/Specifications/retryable-writes/RetryableWriteTestRunner.cs

@@ -19,11 +19,9 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Threading;
 using MongoDB.Bson;
-using MongoDB.Bson.TestHelpers.XunitExtensions;
-using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using MongoDB.Driver.TestHelpers;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -44,7 +42,7 @@ public void RunTestDefinition(TestCase testCase)
             var async = testCase.Async;
 
             VerifyServerRequirements(definition);
-            VerifyFields(definition, "path", "data", "minServerVersion", "maxServerVersion", "tests");
+            VerifyFields(definition, "path", "data", "runOn", "tests");
 
             InitializeCollection(definition);
             RunTest(test, async);
@@ -53,23 +51,14 @@ public void RunTestDefinition(TestCase testCase)
         // private methods
         private void VerifyServerRequirements(BsonDocument definition)
         {
-            RequireServer.Check().ClusterType(ClusterType.ReplicaSet);
-
-            if (CoreTestConfiguration.GetStorageEngine() == "mmapv1")
-            {
-                throw new SkipException("Test skipped because mmapv1 does not support retryable writes.");
-            }
-
-            BsonValue minServerVersion;
-            if (definition.TryGetValue("minServerVersion", out minServerVersion))
+            if (definition.TryGetValue("runOn", out var runOn))
             {
-                RequireServer.Check().VersionGreaterThanOrEqualTo(minServerVersion.AsString);
+                RequireServer.Check().RunOn(runOn.AsBsonArray);
             }
 
-            BsonValue maxServerVersion;
-            if (definition.TryGetValue("maxServerVersion", out maxServerVersion))
+            if (CoreTestConfiguration.GetStorageEngine() == "mmapv1")
             {
-                RequireServer.Check().VersionLessThanOrEqualTo(maxServerVersion.AsString);
+                throw new SkipException("Test skipped because mmapv1 does not support retryable writes.");
             }
         }
 
@@ -96,35 +85,41 @@ private void InitializeCollection(BsonDocument definition)
 
         private void RunTest(BsonDocument test, bool async)
         {
-            VerifyFields(test, "description", "clientOptions", "failPoint", "operation", "outcome");
-            var clientOptions = (BsonDocument)test.GetValue("clientOptions", null);
+            VerifyFields(test, "description", "clientOptions", "failPoint", "operation", "outcome", "useMultipleMongoses");
             var failPoint = (BsonDocument)test.GetValue("failPoint", null);
             var operation = test["operation"].AsBsonDocument;
             var outcome = test["outcome"].AsBsonDocument;
 
-            var client = CreateClient(clientOptions);
-            var database = client.GetDatabase(_databaseName);
-            var collection = database.GetCollection<BsonDocument>(_collectionName);
-            var executableTest = CreateExecutableTest(operation);
-
-            using (ConfigureFailPoint(client, failPoint))
+            using (var client = CreateDisposableClient(test))
             {
-                executableTest.Execute(collection, async);
-            }
+                var database = client.GetDatabase(_databaseName);
+                var collection = database.GetCollection<BsonDocument>(_collectionName);
+                var executableTest = CreateExecutableTest(operation);
+
+                using (ConfigureFailPoint(client, failPoint))
+                {
+                    executableTest.Execute(collection, async);
+                }
 
-            executableTest.VerifyOutcome(collection, outcome);
+                executableTest.VerifyOutcome(collection, outcome);
+            }
         }
 
-        private IMongoClient CreateClient(BsonDocument clientOptions)
+        private DisposableMongoClient CreateDisposableClient(BsonDocument test)
         {
-            var clientSettings = ParseClientOptions(clientOptions);
-            return new MongoClient(clientSettings);
+            var useMultipleShardRouters = test.GetValue("useMultipleMongoses", false).AsBoolean;
+            var clientOptions = (BsonDocument)test.GetValue("clientOptions", null);
+
+            return DriverTestConfiguration.CreateDisposableClient(
+                settings =>
+                {
+                    ParseClientOptions(settings, clientOptions);
+                },
+                useMultipleShardRouters);
         }
 
-        private MongoClientSettings ParseClientOptions(BsonDocument clientOptions)
+        private void ParseClientOptions(MongoClientSettings settings, BsonDocument clientOptions)
         {
-            var settings = DriverTestConfiguration.Client.Settings.Clone();
-
             if (clientOptions == null)
             {
                 settings.RetryWrites = true;
@@ -147,8 +142,6 @@ private MongoClientSettings ParseClientOptions(BsonDocument clientOptions)
                     }
                 }
             }
-
-            return settings;
         }
 
         private IRetryableWriteTest CreateExecutableTest(BsonDocument operation)
@@ -160,13 +153,15 @@ private IRetryableWriteTest CreateExecutableTest(BsonDocument operation)
             {
                 case "bulkWrite": executableTest = new BulkWriteTest(); break;
                 case "deleteOne": executableTest = new DeleteOneTest(); break;
+                case "deleteMany": executableTest = new DeleteManyTest(); break;
                 case "findOneAndDelete": executableTest = new FindOneAndDeleteTest(); break;
                 case "findOneAndReplace": executableTest = new FindOneAndReplaceTest(); break;
                 case "findOneAndUpdate": executableTest = new FindOneAndUpdateTest(); break;
                 case "insertOne": executableTest = new InsertOneTest(); break;
                 case "insertMany": executableTest = new InsertManyTest(); break;
                 case "replaceOne": executableTest = new ReplaceOneTest(); break;
                 case "updateOne": executableTest = new UpdateOneTest(); break;
+                case "updateMany": executableTest = new UpdateManyTest(); break;
                 default: throw new ArgumentException($"Unexpected operation name: {operationName}.");
             }
             executableTest.Initialize(operation);

tests/MongoDB.Driver.Tests/Specifications/retryable-writes/UpdateManyTest.cs

@@ -0,0 +1,89 @@
+/* Copyright 2019-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using FluentAssertions;
+using MongoDB.Bson;
+
+namespace MongoDB.Driver.Tests.Specifications.retryable_writes
+{
+    public class UpdateManyTest : RetryableWriteTestBase
+    {
+        private FilterDefinition<BsonDocument> _filter;
+        private UpdateDefinition<BsonDocument> _update;
+        private readonly UpdateOptions _options = new UpdateOptions();
+        private UpdateResult _result;
+
+        // public methods
+        public override void Initialize(BsonDocument operation)
+        {
+            VerifyFields(operation, "name", "arguments");
+
+            foreach (var argument in operation["arguments"].AsBsonDocument)
+            {
+                switch (argument.Name)
+                {
+                    case "filter":
+                        _filter = argument.Value.AsBsonDocument;
+                        break;
+
+                    case "update":
+                        _update = argument.Value.AsBsonDocument;
+                        break;
+
+                    case "upsert":
+                        _options.IsUpsert = argument.Value.ToBoolean();
+                        break;
+
+                    default:
+                        throw new ArgumentException($"Unexpected argument: {argument.Name}.");
+                }
+            }
+        }
+
+        // protected methods
+        protected override void ExecuteAsync(IMongoCollection<BsonDocument> collection)
+        {
+            _result = collection.UpdateManyAsync(_filter, _update, _options).GetAwaiter().GetResult();
+        }
+
+        protected override void ExecuteSync(IMongoCollection<BsonDocument> collection)
+        {
+            _result = collection.UpdateMany(_filter, _update, _options);
+        }
+
+        protected override void VerifyResult(BsonDocument result)
+        {
+            var expectedResult = ParseResult(result);
+            _result.MatchedCount.Should().Be(expectedResult.MatchedCount);
+            _result.ModifiedCount.Should().Be(expectedResult.ModifiedCount);
+            _result.UpsertedId.Should().Be(expectedResult.UpsertedId);
+        }
+
+        // private methods
+        private UpdateResult ParseResult(BsonDocument result)
+        {
+            VerifyFields(result, "matchedCount", "modifiedCount", "upsertedCount", "upsertedId");
+
+            var matchedCount = result["matchedCount"].ToInt64();
+            var modifiedCount = result["modifiedCount"].ToInt64();
+            var upsertedCount = result["upsertedCount"].ToInt32();
+            var upsertedId = result.GetValue("upsertedId", null);
+            upsertedCount.Should().Be(upsertedId == null ? 0 : 1);
+
+            return new UpdateResult.Acknowledged(matchedCount, modifiedCount, upsertedId);
+        }
+    }
+}