/tests/MongoDB.Driver.Legacy.Tests/MongoCollectionTests.cs

Large files files are truncated, but you can click here to view the full file

/* Copyright 2010-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 System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using MongoDB.Bson;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver.Builders;
using MongoDB.Driver.Core;
using MongoDB.Driver.GeoJsonObjectModel;
using FluentAssertions;
using Xunit;
using MongoDB.Bson.TestHelpers.XunitExtensions;
using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
using MongoDB.Driver.Core.Clusters;
using MongoDB.Driver.Core.Misc;
using MongoDB.Driver.Core.Events;
using MongoDB.Driver.Legacy.Tests;

namespace MongoDB.Driver.Tests
{
    public class MongoCollectionTests
    {
        #region static
        private static readonly SemanticVersion __mapReduceNewServerImplementationServerVersion = new SemanticVersion(4, 3, 0);
        #endregion

        private class TestClass
        {
            public ObjectId Id { get; set; }
            public int X { get; set; }
        }

        private MongoServer _server;
        private MongoServerInstance _primary;
        private MongoDatabase _database;
        private MongoCollection<BsonDocument> _collection;

        public MongoCollectionTests()
        {
            _server = LegacyTestConfiguration.Server;
            _primary = GetPrimary(_server);
            _database = LegacyTestConfiguration.Database;
            _collection = _database.GetCollection(GetType().Name);
        }

        // TODO: more tests for MongoCollection

        [Fact]
        public void TestAggregate()
        {
            if (_server.BuildInfo.Version >= new Version(2, 2, 0))
            {
                _collection.Drop();
                _collection.Insert(new BsonDocument("x", 1));
                _collection.Insert(new BsonDocument("x", 2));
                _collection.Insert(new BsonDocument("x", 3));
                _collection.Insert(new BsonDocument("x", 3));

                var pipeline = new[]
                {
                    new BsonDocument("$group", new BsonDocument { { "_id", "$x" }, { "count", new BsonDocument("$sum", 1) } })
                };
                var expectedResult = new[]
                {
                    new BsonDocument { { "_id", 1 }, { "count", 1 }},
                    new BsonDocument { { "_id", 2 }, { "count", 1 }},
                    new BsonDocument { { "_id", 3 }, { "count", 2 }},
                };

                var result = _collection.Aggregate(new AggregateArgs { Pipeline = pipeline });

                result.Should().BeEquivalentTo(expectedResult);
            }
        }

        [Fact]
        public void TestAggregateAllowDiskUsage()
        {
            _collection.Drop();

            var query = _collection.Aggregate(new AggregateArgs
            {
                Pipeline = new BsonDocument[]
                {
                    new BsonDocument("$project", new BsonDocument("x", 1))
                },
                AllowDiskUse = true
            });
            var results = query.ToList(); // all we can test is that the server doesn't reject the allowDiskUsage argument

            Assert.Equal(0, results.Count);
        }

        [Fact]
        public void TestAggregateCursor()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));

            var query = _collection.Aggregate(new AggregateArgs
            {
                Pipeline = new BsonDocument[]
                {
                    new BsonDocument("$group", new BsonDocument { { "_id", "$x" }, { "count", new BsonDocument("$sum", 1) } })
                },
#pragma warning disable 618
                OutputMode = AggregateOutputMode.Cursor,
#pragma warning disable 618
                BatchSize = 1
            });
            var results = query.ToList();

            var dictionary = new Dictionary<int, int>();
            foreach (var result in results)
            {
                var x = result["_id"].AsInt32;
                var count = result["count"].AsInt32;
                dictionary[x] = count;
            }
            Assert.Equal(3, dictionary.Count);
            Assert.Equal(1, dictionary[1]);
            Assert.Equal(1, dictionary[2]);
            Assert.Equal(2, dictionary[3]);
        }

        [Fact]
        public void TestAggregateExplain()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));

            var result = _collection.AggregateExplain(new AggregateArgs
            {
                Pipeline = new BsonDocument[]
                {
                    new BsonDocument("$project", new BsonDocument("x", "$x"))
                }
            });

            var response = result.Response;
            Assert.True(response.Contains("stages") || response.Contains("queryPlanner"));
        }

        [Fact]
        public void TestAggregateMaxTime()
        {
            using (var failpoint = new FailPoint(FailPointName.MaxTimeAlwaysTimeout, _server, _primary))
            {
                if (failpoint.IsSupported())
                {
                    _collection.Drop();
                    _collection.Insert(new BsonDocument("x", 1));

                    failpoint.SetAlwaysOn();
                    var query = _collection.Aggregate(new AggregateArgs
                    {
                        Pipeline = new BsonDocument[]
                        {
                            new BsonDocument("$match", Query.Exists("_id").ToBsonDocument())
                        },
                        MaxTime = TimeSpan.FromMilliseconds(1)
                    });
                    Assert.Throws<MongoExecutionTimeoutException>(() => query.ToList());
                }
            }
        }

        [SkippableTheory]
        [ParameterAttributeData]
        public void TestAggregateOutputToCollection(
            [Values("$out", "$merge")] string lastStageName,
            [Values(false, true)] bool usingDifferentOutputDatabase)
        {
            RequireServer.Check();

            var inputDatabaseName = _collection.Database.Name;
            var inputCollectionName = _collection.Name;
            var outputDatabaseName = usingDifferentOutputDatabase ? $"{inputDatabaseName}-output" : inputDatabaseName;
            var outputCollectionName = $"{inputCollectionName}-output";

            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));
            EnsureDatabaseExists(outputDatabaseName);

            var pipeline = new List<BsonDocument> { new BsonDocument("$group", new BsonDocument { { "_id", "$x" }, { "count", new BsonDocument("$sum", 1) } }) };
            switch (lastStageName)
            {
                case "$out":
                    RequireServer.Check().Supports(Feature.AggregateOut);
                    BsonValue outValue;
                    if (usingDifferentOutputDatabase)
                    {
                        RequireServer.Check().Supports(Feature.AggregateOutToDifferentDatabase);
                        outValue = new BsonDocument { { "db", outputDatabaseName }, { "coll", outputCollectionName } };
                    }
                    else
                    {
                        outValue = outputCollectionName;
                    }
                    pipeline.Add(new BsonDocument("$out", outValue));
                    break;

                case "$merge":
                    RequireServer.Check().Supports(Feature.AggregateMerge);
                    BsonValue intoValue;
                    if (usingDifferentOutputDatabase)
                    {
                        intoValue = new BsonDocument { { "db", outputDatabaseName }, { "coll", outputCollectionName } };
                    }
                    else
                    {
                        intoValue = outputCollectionName;
                    }
                    pipeline.Add(new BsonDocument("$merge", new BsonDocument("into", intoValue)));
                    break;

                default:
                    throw new Exception($"Invalid lastStageName: \"{lastStageName}\".");
            }

            var query = _collection.Aggregate(new AggregateArgs
            {
                BypassDocumentValidation = true,
                Pipeline = pipeline
            });
            var results = query.ToList();

            var dictionary = new Dictionary<int, int>();
            foreach (var result in results)
            {
                var x = result["_id"].AsInt32;
                var count = result["count"].AsInt32;
                dictionary[x] = count;
            }
            Assert.Equal(3, dictionary.Count);
            Assert.Equal(1, dictionary[1]);
            Assert.Equal(1, dictionary[2]);
            Assert.Equal(2, dictionary[3]);
        }

        [SkippableFact]
        public void TestAggregateWriteConcern()
        {
            RequireServer.Check().Supports(Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);
            var writeConcern = new WriteConcern(9, wTimeout: TimeSpan.FromMilliseconds(1));
            var args = new AggregateArgs
            {
                Pipeline = new[] { BsonDocument.Parse("{ $out : 'out' }") }
            };

            var exception = Record.Exception(() => _collection.WithWriteConcern(writeConcern).Aggregate(args));

            exception.Should().BeOfType<MongoWriteConcernException>();
        }

        [Fact]
        public void TestBulkDelete()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Find(Query.EQ("x", 1)).RemoveOne();
            bulk.Find(Query.EQ("x", 3)).RemoveOne();
            bulk.Execute();

            Assert.Equal(1, _collection.Count());
            Assert.Equal(2, _collection.FindOne()["x"].ToInt32());
        }

        [Fact]
        public void TestBulkInsert()
        {
            _collection.Drop();

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Insert(new BsonDocument("x", 1));
            bulk.Insert(new BsonDocument("x", 2));
            bulk.Insert(new BsonDocument("x", 3));
            bulk.Execute();

            Assert.Equal(3, _collection.Count());
        }

        [Fact]
        public void TestBulkUpdate()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Find(Query.GT("x", 0)).Update(Update.Set("z", 1));
            bulk.Find(Query.EQ("x", 3)).UpdateOne(Update.Set("z", 3));
            bulk.Find(Query.EQ("x", 4)).Upsert().UpdateOne(Update.Set("z", 4));
            bulk.Execute();

            Assert.Equal(4, _collection.Count());
            foreach (var document in _collection.FindAll())
            {
                var x = document["x"].ToInt32();
                var z = document["z"].ToInt32();
                var expected = (x == 2) ? 1 : x;
                Assert.Equal(expected, z);
            }
        }

        [Fact]
        public void TestBulkWrite()
        {
            _collection.Drop();

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Insert(new BsonDocument("x", 1));
            bulk.Insert(new BsonDocument("x", 2));
            bulk.Insert(new BsonDocument("x", 3));
            bulk.Insert(new BsonDocument("x", 4));
            bulk.Find(Query.GT("x", 2)).Update(Update.Inc("x", 10));
            bulk.Find(Query.EQ("x", 13)).RemoveOne();
            bulk.Find(Query.EQ("x", 14)).RemoveOne();
            bulk.Execute();

            Assert.Equal(2, _collection.Count());
        }

        [Fact]
        public void TestBulkWriteCounts()
        {
            _collection.Drop();

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Insert(new BsonDocument("x", 1));
            bulk.Find(Query.EQ("x", 1)).UpdateOne(Update.Set("x", 2));
            bulk.Find(Query.EQ("x", 2)).RemoveOne();
            var result = bulk.Execute();

            Assert.Equal(1, result.DeletedCount);
            Assert.Equal(1, result.InsertedCount);
            Assert.Equal(true, result.IsModifiedCountAvailable);
            Assert.Equal(1, result.ModifiedCount);
            Assert.Equal(3, result.RequestCount);
            Assert.Equal(1, result.MatchedCount);
        }

        [Fact]
        public void TestBulkWriteCountsWithUpsert()
        {
            _collection.Drop();
            var id = new BsonObjectId(ObjectId.GenerateNewId());

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Find(Query.EQ("_id", id)).Upsert().UpdateOne(Update.Set("x", 2));
            bulk.Find(Query.EQ("_id", id)).Upsert().UpdateOne(Update.Set("x", 2));
            bulk.Find(Query.EQ("_id", id)).UpdateOne(Update.Set("x", 3));
            var result = bulk.Execute();

            Assert.Equal(0, result.DeletedCount);
            Assert.Equal(0, result.InsertedCount);
            Assert.Equal(true, result.IsModifiedCountAvailable);
            Assert.Equal(1, result.ModifiedCount);
            Assert.Equal(3, result.RequestCount);
            Assert.Equal(2, result.MatchedCount);
            Assert.Equal(1, result.Upserts.Count);
            Assert.Equal(0, result.Upserts.First().Index);
            Assert.Equal(id, result.Upserts.First().Id);
        }

        [Fact]
        public void TestBulkWriteOrdered()
        {
            _collection.Drop();

            var bulk = _collection.InitializeOrderedBulkOperation();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Find(Query.EQ("x", 1)).RemoveOne();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Find(Query.EQ("x", 1)).RemoveOne();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Execute();

            Assert.Equal(1, _collection.Count());
        }

        [Fact]
        public void TestBulkWriteUnordered()
        {
            _collection.Drop();

            var bulk = _collection.InitializeUnorderedBulkOperation();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Find(Query.EQ("x", 1)).RemoveOne();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Find(Query.EQ("x", 1)).RemoveOne();
            bulk.Find(Query.EQ("x", 1)).Upsert().UpdateOne(Update.Set("y", 1));
            bulk.Execute();

            Assert.Equal(0, _collection.Count());
        }

        [Fact]
        public void TestConstructorArgumentChecking()
        {
            var settings = new MongoCollectionSettings();
#pragma warning disable 618
            Assert.Throws<ArgumentNullException>(() => { new MongoCollection<BsonDocument>(null, "name", settings); });
            Assert.Throws<ArgumentNullException>(() => { new MongoCollection<BsonDocument>(_database, null, settings); });
            Assert.Throws<ArgumentNullException>(() => { new MongoCollection<BsonDocument>(_database, "name", null); });
            Assert.Throws<ArgumentOutOfRangeException>(() => { new MongoCollection<BsonDocument>(_database, "", settings); });
#pragma warning restore
        }

        [Fact]
        public void TestCountZero()
        {
            _collection.Drop();
            var count = _collection.Count();
            Assert.Equal(0, count);
        }

        [SkippableFact]
        public void TestCountUsesImplicitSession()
        {
            RequireServer.Check();

            var events = new EventCapturer().Capture<CommandStartedEvent>(x => x.CommandName == "count");
            using (var client = DriverTestConfiguration.CreateDisposableClient(events))
            {
                var server = client.GetServer();
                var database = server.GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName);
                var collection = database.GetCollection<BsonDocument>(DriverTestConfiguration.CollectionNamespace.CollectionName);
                collection.Count();

                var commandStartedEvent = events.Next().Should().BeOfType<CommandStartedEvent>().Subject;
                var command = commandStartedEvent.Command;
                var areSessionsSupported = AreSessionsSupported(client);
                command.Contains("lsid").Should().Be(areSessionsSupported);
            }
        }

        [Fact]
        public void TestCountOne()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument());
            var count = _collection.Count();
            Assert.Equal(1, count);
        }

        [Fact]
        public void TestCountWithMaxTime()
        {
            using (var failpoint = new FailPoint(FailPointName.MaxTimeAlwaysTimeout, _server, _primary))
            {
                if (failpoint.IsSupported())
                {
                    failpoint.SetAlwaysOn();
                    var args = new CountArgs { MaxTime = TimeSpan.FromMilliseconds(1) };
                    Assert.Throws<MongoExecutionTimeoutException>(() => _collection.Count(args));
                }
            }
        }

        [SkippableFact]
        public void TestCountWithMaxTimeFromFind()
        {
            RequireServer.Check();
            using (var failpoint = new FailPoint(FailPointName.MaxTimeAlwaysTimeout, _server, _primary))
            {
                if (failpoint.IsSupported())
                {
                    failpoint.SetAlwaysOn();
                    Assert.Throws<MongoExecutionTimeoutException>(() => _collection.Find(Query.EQ("x", 1)).SetMaxTime(TimeSpan.FromMilliseconds(1)).Count());
                }
            }
        }

        [Fact]
        public void TestCountWithQuery()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            var query = Query.EQ("x", 1);
            var count = _collection.Count(query);
            Assert.Equal(1, count);
        }

        [SkippableFact]
        public void TestCountWithReadPreferenceFromFind()
        {
            RequireServer.Check().ClusterType(ClusterType.ReplicaSet);
            var all = LegacyTestConfiguration.Server.Secondaries.Length + 1;
            if (all > 1)
            {
                _collection.Drop();
                var options = new MongoInsertOptions { WriteConcern = new WriteConcern(w: all) };
                _collection.Insert(new BsonDocument("x", 1), options);
                _collection.Insert(new BsonDocument("x", 2), options);
                var count = _collection.Find(Query.EQ("x", 1)).SetReadPreference(ReadPreference.Secondary).Count();
                Assert.Equal(1, count);
            }
        }

        [SkippableFact]
        public void TestCountWithHint()
        {
            RequireServer.Check();
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.CreateIndex(IndexKeys.Ascending("x"));
            var query = Query.EQ("x", 1);
            var count = _collection.Count(new CountArgs
            {
                Hint = new BsonDocument("x", 1),
                Query = query
            });
            Assert.Equal(1, count);
        }

        [SkippableFact]
        public void TestCountWithHintFromFind()
        {
            RequireServer.Check();
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.CreateIndex(IndexKeys.Ascending("x"));
            var count = _collection.Find(Query.EQ("x", 1)).SetHint(new BsonDocument("x", 1)).Count();
            Assert.Equal(1, count);
        }

        [SkippableFact]
        public void TestCountWithHintAndLimitFromFind()
        {
            RequireServer.Check();
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.CreateIndex(IndexKeys.Ascending("x"));
            var count = _collection.Find(Query.EQ("x", 1)).SetHint(new BsonDocument("x", 1)).SetLimit(2).Size();
            Assert.Equal(1, count);
        }

        [Fact]
        public void TestCreateCollection()
        {
            var collection = LegacyTestConfiguration.Collection;
            collection.Drop();
            Assert.False(collection.Exists());
            _database.CreateCollection(collection.Name);
            Assert.True(collection.Exists());
        }

        [SkippableTheory]
        [ParameterAttributeData]
        public void TestCreateCollectionSetAutoIndexId(
            [Values(false, true)]
            bool autoIndexId)
        {
            RequireServer.Check().VersionLessThan("3.7.0");
            var collection = _database.GetCollection("cappedcollection");
            collection.Drop();
#pragma warning disable 618
            var options = CollectionOptions.SetAutoIndexId(autoIndexId);
#pragma warning restore
            var expectedIndexCount = autoIndexId ? 1 : 0;

            _database.CreateCollection(collection.Name, options);

            var indexCount = collection.GetIndexes().Count;
            Assert.Equal(expectedIndexCount, indexCount);
        }

        [SkippableFact]
        public void TestCreateCollectionSetCappedSetMaxDocuments()
        {
            RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).StorageEngine("mmapv1");
            var collection = _database.GetCollection("cappedcollection");
            collection.Drop();
            Assert.False(collection.Exists());
            var options = CollectionOptions.SetCapped(true).SetMaxSize(10000).SetMaxDocuments(1000);
            _database.CreateCollection(collection.Name, options);
            Assert.True(collection.Exists());
            var stats = collection.GetStats();
            Assert.True(stats.IsCapped);
            Assert.True(stats.StorageSize >= 10000);
            Assert.True(stats.MaxDocuments == 1000);
        }

        [SkippableFact]
        public void TestCreateCollectionSetCappedSetMaxSize()
        {
            RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).StorageEngine("mmapv1");
            var collection = _database.GetCollection("cappedcollection");
            collection.Drop();
            Assert.False(collection.Exists());
            var options = CollectionOptions.SetCapped(true).SetMaxSize(10000);
            _database.CreateCollection(collection.Name, options);
            Assert.True(collection.Exists());
            var stats = collection.GetStats();
            Assert.True(stats.IsCapped);
            Assert.True(stats.StorageSize >= 10000);
        }

        [SkippableTheory]
        [ParameterAttributeData]
        public void TestCreateCollectionSetNoPadding(
            [Values(false, true)]
            bool noPadding)
        {
            RequireServer.Check().VersionGreaterThanOrEqualTo("3.0").ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).StorageEngine("mmapv1");
            var collection = _database.GetCollection("cappedcollection");
            collection.Drop();
            var userFlags = noPadding ? CollectionUserFlags.NoPadding : CollectionUserFlags.None;
            var options = new CollectionOptionsDocument
            {
                { "flags", (int)userFlags }
            };

            _database.CreateCollection(collection.Name, options);

            var stats = collection.GetStats();
            Assert.Equal(userFlags, stats.UserFlags);
        }

        [SkippableTheory]
        [ParameterAttributeData]
        public void TestCreateCollectionSetUsePowerOf2Sizes(
            [Values(false, true)]
            bool usePowerOf2Sizes)
        {
            RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).StorageEngine("mmapv1");
            var collection = _database.GetCollection("cappedcollection");
            collection.Drop();
            var userFlags = usePowerOf2Sizes ? CollectionUserFlags.UsePowerOf2Sizes : CollectionUserFlags.None;
            var options = new CollectionOptionsDocument
            {
                { "flags", (int)userFlags }
            };

            _database.CreateCollection(collection.Name, options);

            var stats = collection.GetStats();
            Assert.Equal(userFlags, stats.UserFlags);
        }

        [Fact]
        public void TestCreateIndex()
        {
            void assertNamespace(IndexInfo indexInfo)
            {
                if (CoreTestConfiguration.ServerVersion < new SemanticVersion(4, 3, 0, ""))
                {
                    Assert.Equal(_collection.FullName, indexInfo.Namespace);
                }
                else
                {
                    var exception = Record.Exception(() => indexInfo.Namespace);
                    var e = exception.Should().BeOfType<KeyNotFoundException>().Subject;
                    e.Message.Should().Be("Element 'ns' not found.");
                }
            }

            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));

            var indexes = _collection.GetIndexes().ToList();
            Assert.Equal(1, indexes.Count);
            Assert.Equal(false, indexes[0].DroppedDups);
            Assert.Equal(false, indexes[0].IsBackground);
            Assert.Equal(false, indexes[0].IsSparse);
            Assert.Equal(false, indexes[0].IsUnique);
            Assert.Equal(new IndexKeysDocument("_id", 1), indexes[0].Key);
            Assert.Equal("_id_", indexes[0].Name);
            assertNamespace(indexes[0]);
            Assert.True(indexes[0].Version >= 0);

            var result = _collection.CreateIndex("x");

            var expectedResult = new ExpectedWriteConcernResult();
            CheckExpectedResult(expectedResult, result);

            indexes = _collection.GetIndexes().OrderBy(x => x.Name).ToList();
            Assert.Equal(2, indexes.Count);
            Assert.Equal(false, indexes[0].DroppedDups);
            Assert.Equal(false, indexes[0].IsBackground);
            Assert.Equal(false, indexes[0].IsSparse);
            Assert.Equal(false, indexes[0].IsUnique);
            Assert.Equal(new IndexKeysDocument("_id", 1), indexes[0].Key);
            Assert.Equal("_id_", indexes[0].Name);
            assertNamespace(indexes[0]);
            Assert.True(indexes[0].Version >= 0);
            Assert.Equal(false, indexes[1].DroppedDups);
            Assert.Equal(false, indexes[1].IsBackground);
            Assert.Equal(false, indexes[1].IsSparse);
            Assert.Equal(false, indexes[1].IsUnique);
            Assert.Equal(new IndexKeysDocument("x", 1), indexes[1].Key);
            Assert.Equal("x_1", indexes[1].Name);
            assertNamespace(indexes[1]);
            Assert.True(indexes[1].Version >= 0);

            // note: DropDups is silently ignored in server 2.8
            if (_primary.BuildInfo.Version < new Version(2, 7, 0))
            {
                _collection.DropAllIndexes();
                var options = IndexOptions.SetBackground(true).SetDropDups(true).SetSparse(true).SetUnique(true);
                result = _collection.CreateIndex(IndexKeys.Ascending("x").Descending("y"), options);

                expectedResult = new ExpectedWriteConcernResult();
                CheckExpectedResult(expectedResult, result);

                indexes = _collection.GetIndexes().OrderBy(x => x.Name).ToList();
                Assert.Equal(2, indexes.Count);
                Assert.Equal(false, indexes[0].DroppedDups);
                Assert.Equal(false, indexes[0].IsBackground);
                Assert.Equal(false, indexes[0].IsSparse);
                Assert.Equal(false, indexes[0].IsUnique);
                Assert.Equal(new IndexKeysDocument("_id", 1), indexes[0].Key);
                Assert.Equal("_id_", indexes[0].Name);
                Assert.Equal(_collection.FullName, indexes[0].Namespace);
                Assert.True(indexes[0].Version >= 0);
                Assert.Equal(true, indexes[1].DroppedDups);
                Assert.Equal(true, indexes[1].IsBackground);
                Assert.Equal(true, indexes[1].IsSparse);
                Assert.Equal(true, indexes[1].IsUnique);
                Assert.Equal(new IndexKeysDocument { { "x", 1 }, { "y", -1 } }, indexes[1].Key);
                Assert.Equal("x_1_y_-1", indexes[1].Name);
                Assert.Equal(_collection.FullName, indexes[1].Namespace);
                Assert.True(indexes[1].Version >= 0);
            }
        }

        [SkippableFact]
        public void TestCreateIndexWithStorageEngine()
        {
            RequireServer.Check().StorageEngine("wiredTiger");
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));

            _collection.CreateIndex(
               IndexKeys.Ascending("x"),
                IndexOptions.SetStorageEngineOptions(
                    new BsonDocument("wiredTiger", new BsonDocument("configString", "block_compressor=zlib"))));

            var result = _collection.GetIndexes();
            Assert.Equal(2, result.Count);
        }

        [SkippableFact]
        public void TestCreateIndexWriteConcern()
        {
            RequireServer.Check().Supports(Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);
            var writeConcern = new WriteConcern(9, wTimeout: TimeSpan.FromMilliseconds(1));
            var keys = IndexKeys.Ascending("x");

            var exception = Record.Exception(() => _collection.WithWriteConcern(writeConcern).CreateIndex(keys));

            exception.Should().BeOfType<MongoWriteConcernException>();
        }

        [Fact]
        public void TestCreateIndexWithPartialFilterExpression()
        {
            _collection.Drop();
            var keys = IndexKeys.Ascending("x");
            var options = IndexOptions<BsonDocument>.SetPartialFilterExpression(Query.GT("x", 0));

            _collection.CreateIndex(keys, options);

            var indexes = _collection.GetIndexes();
            var index = indexes.Where(i => i.Name == "x_1").Single();
            Assert.Equal(BsonDocument.Parse("{ x : { $gt : 0 } }"), index.RawDocument["partialFilterExpression"]);
        }

        [Fact]
        public void TestDistinct()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));
            var values = new HashSet<BsonValue>(_collection.Distinct("x"));
            Assert.Equal(3, values.Count);
            Assert.Equal(true, values.Contains(1));
            Assert.Equal(true, values.Contains(2));
            Assert.Equal(true, values.Contains(3));
            Assert.Equal(false, values.Contains(4));
        }

        [Fact]
        public void TestDistinct_Typed()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));
            var values = new HashSet<int>(_collection.Distinct<int>("x"));
            Assert.Equal(3, values.Count);
            Assert.Equal(true, values.Contains(1));
            Assert.Equal(true, values.Contains(2));
            Assert.Equal(true, values.Contains(3));
            Assert.Equal(false, values.Contains(4));
        }

        [Fact]
        public void TestDistinctWithMaxTime()
        {
            using (var failpoint = new FailPoint(FailPointName.MaxTimeAlwaysTimeout, _server, _primary))
            {
                if (failpoint.IsSupported())
                {
                    _collection.Drop();
                    _collection.Insert(new BsonDocument("x", 1)); // ensure collection is not empty

                    failpoint.SetAlwaysOn();
                    var args = new DistinctArgs
                    {
                        Key = "x",
                        MaxTime = TimeSpan.FromMilliseconds(1)
                    };
                    Assert.Throws<MongoExecutionTimeoutException>(() => _collection.Distinct<BsonValue>(args));
                }
            }
        }

        [Fact]
        public void TestDistinctWithQuery()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));
            var query = Query.LTE("x", 2);
            var values = new HashSet<BsonValue>(_collection.Distinct("x", query));
            Assert.Equal(2, values.Count);
            Assert.Equal(true, values.Contains(1));
            Assert.Equal(true, values.Contains(2));
            Assert.Equal(false, values.Contains(3));
            Assert.Equal(false, values.Contains(4));
        }

        [Fact]
        public void TestDistinctWithQuery_Typed()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument("x", 1));
            _collection.Insert(new BsonDocument("x", 2));
            _collection.Insert(new BsonDocument("x", 3));
            _collection.Insert(new BsonDocument("x", 3));
            var query = Query.LTE("x", 2);
            var values = new HashSet<int>(_collection.Distinct<int>("x", query));
            Assert.Equal(2, values.Count);
            Assert.Equal(true, values.Contains(1));
            Assert.Equal(true, values.Contains(2));
            Assert.Equal(false, values.Contains(3));
            Assert.Equal(false, values.Contains(4));
        }

        [Fact]
        public void TestDropAllIndexes()
        {
            _collection.Drop();
            _collection.CreateIndex("x");

            _collection.DropAllIndexes();

            _collection.IndexExistsByName("_id_").Should().BeTrue();
            _collection.IndexExistsByName("x_1").Should().BeFalse();
        }

        [Fact]
        public void TestDropIndex()
        {
            _collection.Drop();
            _collection.CreateIndex("x");

            _collection.DropIndex("x");

            _collection.IndexExistsByName("_id_").Should().BeTrue();
            _collection.IndexExistsByName("x_1").Should().BeFalse();
        }

        [SkippableFact]
        public void TestDropIndexWriteConcern()
        {
            RequireServer.Check().Supports(Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);

            _collection.Drop();
            _collection.CreateIndex("x");
            var writeConcern = new WriteConcern(9, wTimeout: TimeSpan.FromMilliseconds(1));

            var exception = Record.Exception(() => _collection.WithWriteConcern(writeConcern).DropIndex("x"));

            exception.Should().BeOfType<MongoWriteConcernException>();
        }

        [Fact]
        public void TestCreateIndexTimeToLive()
        {
            if (_server.BuildInfo.Version >= new Version(2, 2, 0))
            {
                _collection.Drop();

                var keys = IndexKeys.Ascending("ts");
                var options = IndexOptions.SetTimeToLive(TimeSpan.FromHours(1));
                var result = _collection.CreateIndex(keys, options);

                var expectedResult = new ExpectedWriteConcernResult();
                CheckExpectedResult(expectedResult, result);

                var indexes = _collection.GetIndexes();
                Assert.Equal("_id_", indexes[0].Name);
                Assert.Equal("ts_1", indexes[1].Name);
                Assert.Equal(TimeSpan.FromHours(1), indexes[1].TimeToLive);
            }
        }

        [Fact]
        public void TestExplain()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "x", 4 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 2 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 3 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 2 } });
            _collection.Find(Query.GT("x", 3)).Explain();
        }

        [Fact]
        public void TestFind()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "x", 4 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 2 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 3 }, { "y", 2 } });
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 2 } });
            var result = _collection.Find(Query.GT("x", 3));
            Assert.Equal(1, result.Count());
            Assert.Equal(4, result.Select(x => x["x"].AsInt32).FirstOrDefault());
        }

        [Fact]
        public void TestFindAndModify()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "_id", 1 }, { "priority", 1 }, { "inprogress", false }, { "name", "abc" } });
            _collection.Insert(new BsonDocument { { "_id", 2 }, { "priority", 2 }, { "inprogress", false }, { "name", "def" } });
            _collection.Insert(new BsonDocument { { "_id", 3 }, { "priority", 3 }, { "inprogress", false }, { "name", "ghi" } });


            var started = DateTime.UtcNow;
            started = started.AddTicks(-(started.Ticks % 10000)); // adjust for MongoDB DateTime precision
            var args = new FindAndModifyArgs
            {
                BypassDocumentValidation = true,
                Query = Query.EQ("inprogress", false),
                SortBy = SortBy.Descending("priority"),
                Update = Update.Set("inprogress", true).Set("started", started)
            };
            var result = _collection.FindAndModify(args);

            Assert.True(result.Ok);
            Assert.Equal(3, result.ModifiedDocument["_id"].AsInt32);
            Assert.Equal(3, result.ModifiedDocument["priority"].AsInt32);
            Assert.Equal(false, result.ModifiedDocument["inprogress"].AsBoolean);
            Assert.Equal("ghi", result.ModifiedDocument["name"].AsString);
            Assert.False(result.ModifiedDocument.Contains("started"));

            started = DateTime.UtcNow;
            started = started.AddTicks(-(started.Ticks % 10000)); // adjust for MongoDB DateTime precision
            args = new FindAndModifyArgs
            {
                BypassDocumentValidation = true,
                Query = Query.EQ("inprogress", false),
                SortBy = SortBy.Descending("priority"),
                Update = Update.Set("inprogress", true).Set("started", started),
                VersionReturned = FindAndModifyDocumentVersion.Original
            };
            result = _collection.FindAndModify(args);

            Assert.True(result.Ok);
            Assert.Equal(2, result.ModifiedDocument["_id"].AsInt32);
            Assert.Equal(2, result.ModifiedDocument["priority"].AsInt32);
            Assert.Equal(false, result.ModifiedDocument["inprogress"].AsBoolean);
            Assert.Equal("def", result.ModifiedDocument["name"].AsString);
            Assert.False(result.ModifiedDocument.Contains("started"));

            started = DateTime.UtcNow;
            started = started.AddTicks(-(started.Ticks % 10000)); // adjust for MongoDB DateTime precision
            args = new FindAndModifyArgs
            {
                Query = Query.EQ("inprogress", false),
                SortBy = SortBy.Descending("priority"),
                Update = Update.Set("inprogress", true).Set("started", started),
                VersionReturned = FindAndModifyDocumentVersion.Modified
            };
            result = _collection.FindAndModify(args);

            Assert.True(result.Ok);
            Assert.Equal(1, result.ModifiedDocument["_id"].AsInt32);
            Assert.Equal(1, result.ModifiedDocument["priority"].AsInt32);
            Assert.Equal(true, result.ModifiedDocument["inprogress"].AsBoolean);
            Assert.Equal("abc", result.ModifiedDocument["name"].AsString);
            Assert.Equal(started, result.ModifiedDocument["started"].ToUniversalTime());
        }

        [Fact]
        public void TestFindAndModifyWithMaxTime()
        {
            using (var failpoint = new FailPoint(FailPointName.MaxTimeAlwaysTimeout, _server, _primary))
            {
                if (failpoint.IsSupported())
                {
                    failpoint.SetAlwaysOn();
                    var args = new FindAndModifyArgs
                    {
                        Update = Update.Set("x", 1),
                        MaxTime = TimeSpan.FromMilliseconds(1)
                    };
                    Assert.Throws<MongoExecutionTimeoutException>(() => _collection.FindAndModify(args));
                }
            }
        }

        [Fact]
        public void TestFindAndModifyNoMatchingDocument()
        {
            _collection.Drop();

            var started = DateTime.UtcNow;
            started = started.AddTicks(-(started.Ticks % 10000)); // adjust for MongoDB DateTime precision
            var args = new FindAndModifyArgs
            {
                Query = Query.EQ("inprogress", false),
                SortBy = SortBy.Descending("priority"),
                Update = Update.Set("inprogress", true).Set("started", started),
                VersionReturned = FindAndModifyDocumentVersion.Original
            };
            var result = _collection.FindAndModify(args);

            Assert.True(result.Ok);
            Assert.Null(result.ErrorMessage);
            Assert.Null(result.ModifiedDocument);
            Assert.Null(result.GetModifiedDocumentAs<FindAndModifyClass>());
        }

        [Fact]
        public void TestFindAndModifyUpsert()
        {
            _collection.Drop();

            var args = new FindAndModifyArgs
            {
                Query = Query.EQ("name", "Tom"),
                Update = Update.Inc("count", 1),
                Upsert = true,
                VersionReturned = FindAndModifyDocumentVersion.Modified
            };
            var result = _collection.FindAndModify(args);

            Assert.Equal("Tom", result.ModifiedDocument["name"].AsString);
            Assert.Equal(1, result.ModifiedDocument["count"].AsInt32);
        }

        [SkippableFact]
        public void TestFindAndModifyReplaceWithWriteConcernError()
        {
            RequireServer.Check().Supports(Feature.FindAndModifyWriteConcern).ClusterType(ClusterType.ReplicaSet);
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "_id", 1 }, { "x", 1 } });
            var collectionSettings = new MongoCollectionSettings
            {
                WriteConcern = new WriteConcern(9, wTimeout: TimeSpan.FromMilliseconds(1))
            };
            var collection = _database.GetCollection(_collection.Name, collectionSettings);
            var args = new FindAndModifyArgs
            {
                Query = Query.EQ("_id", 1),
                Update = Update.Replace(new BsonDocument { { "_id", 1 }, { "x", 2 } }),
                VersionReturned = FindAndModifyDocumentVersion.Modified
            };

            BsonDocument modifiedDocument;
            if (_server.BuildInfo.Version >= new Version(3, 2, 0))
            {
                Action action = () => collection.FindAndModify(args);

                var exception = action.ShouldThrow<MongoWriteConcernException>().Which;
                var commandResult = exception.Result;
                modifiedDocument = commandResult["value"].AsBsonDocument;
            }
            else
            {
                var result = collection.FindAndModify(args);

                modifiedDocument = result.ModifiedDocument;
            }

            modifiedDocument.Should().Be("{ _id : 1, x : 2 }");
        }

        [SkippableFact]
        public void TestFindAndModifyUpdateWithWriteConcernError()
        {
            RequireServer.Check().Supports(Feature.FindAndModifyWriteConcern).ClusterType(ClusterType.ReplicaSet);
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "_id", 1 }, { "x", 1 } });
            var collectionSettings = new MongoCollectionSettings
            {
                WriteConcern = new WriteConcern(9, wTimeout: TimeSpan.FromMilliseconds(1))
            };
            var collection = _database.GetCollection(_collection.Name, collectionSettings);
            var args = new FindAndModifyArgs
            {
                Query = Query.EQ("x", 1),
                Update = Update.Set("x", 2),
                VersionReturned = FindAndModifyDocumentVersion.Modified
            };

            BsonDocument modifiedDocument;
            if (_server.BuildInfo.Version >= new Version(3, 2, 0))
            {
                Action action = () => collection.FindAndModify(args);

                var exception = action.ShouldThrow<MongoWriteConcernException>().Which;
                var commandResult = exception.Result;
                modifiedDocument = commandResult["value"].AsBsonDocument;
            }
            else
            {
                var result = collection.FindAndModify(args);

                modifiedDocument = result.ModifiedDocument;
            }

            modifiedDocument.Should().Be("{ _id : 1, x : 2 }");
        }

        private class FindAndModifyClass
        {
            public ObjectId Id;
            public int Value;
        }

        [Fact]
        public void TestFindAndModifyTyped()
        {
            _collection.Drop();
            var obj = new FindAndModifyClass { Id = ObjectId.GenerateNewId(), Value = 1 };
            _collection.Insert(obj);

            var args = new FindAndModifyArgs
            {
                Query = Query.EQ("_id", obj.Id),
                Update = Update.Inc("Value", 1),
                VersionReturned = FindAndModifyDocumentVersion.Modified
            };
            var result = _collection.FindAndModify(args);
            var rehydrated = result.GetModifiedDocumentAs<FindAndModifyClass>();

            Assert.Equal(obj.Id, rehydrated.Id);
            Assert.Equal(2, rehydrated.Value);
        }

        [Fact]
        public void TestFindAndRemove()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 1 } });
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 2 } });

            var args = new FindAndRemoveArgs
            {
                Query = Query.EQ("x", 1),
                SortBy = SortBy.Ascending("y")
            };
            var result = _collection.FindAndRemove(args);
            Assert.Equal(1, result.ModifiedDocument["y"].ToInt32());
            Assert.Equal(1, _collection.Count());
        }

        [Fact]
        public void TestFindAndRemoveNoMatchingDocument()
        {
            _collection.Drop();

            var args = new FindAndRemoveArgs
            {
                Query = Query.EQ("inprogress", false),
                SortBy = SortBy.Descending("priority")
            };
            var result = _collection.FindAndRemove(args);

            Assert.True(result.Ok);
            Assert.Null(result.ErrorMessage);
            Assert.Null(result.ModifiedDocument);
            Assert.Null(result.GetModifiedDocumentAs<FindAndModifyClass>());
        }

        [Fact]
        public void TestFindAndRemoveWithFields()
        {
            _collection.Drop();
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 1 } });
            _collection.Insert(new BsonDocument { { "x", 1 }, { "y", 2 } });

            var args = new FindAndRemoveArgs
            {
                Query = Query.EQ("x", 1),
                SortBy = SortBy.Ascending("y"),
                Fields = Fields.Include("_id")
            };
            var result = _collection.FindAndRemove(args);
            Assert.Equal(1, result.ModifiedDocument.ElementCount);
            Assert.Equal("_id", result.ModifiedDocument.GetElement(0).Name);
        }

        [Fact]
        public void TestFindAndRemoveWithMaxTime()
        {
            var server = LegacyTestConfiguration.GetServer(retryWrites: false);
            var primary =…