monorepo/LCU.API.Internal.Document/OwnerNumberMigrationTest/TestDoubles/FakeMongoCollectionFactory.cs

using System.Net;
using LCU.API.Internal.DocumentLib.Utilities;
using Mongo2Go;
using MongoDB.Bson;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;
using MongoDB.Driver.Core.Connections;
using MongoDB.Driver.Core.Servers;

namespace OwnerNumberMigrationTest.TestDoubles;

public class FakeMongoCollectionFactory : IMongoCollectionFactory, IDisposable
{
    private readonly MongoDbRunner _runner = MongoDbRunner.Start();
    public string ConnectionString => _runner.ConnectionString;
    public string DatabaseName<T>() => typeof(T).Name + DatabasePostFix;
    public string CollectionName<T>() => typeof(T).Name;
    public string DatabasePostFix { get; set; } = string.Empty;
    public TimeSpan? TooManyRequestsOnWriteFor { get; set; }

    public IMongoCollection<T> GetCollection<T>()
    {
        var collection = new MongoClient(_runner.ConnectionString)
            .GetDatabase(DatabaseName<T>())
            .GetCollection<T>(CollectionName<T>());

        if (TooManyRequestsOnWriteFor is not null)
        {
            collection = new TooManyRequestsOnWriteCollectionDecorator<T>(collection, TooManyRequestsOnWriteFor.Value);
        }

        return collection;
    }

    public void Dispose()
    {
        _runner.Dispose();
    }
}

public class TooManyRequestsOnWriteCollectionDecorator<T> : IMongoCollection<T>
{
    private IMongoCollection<T> _collection;

    private readonly TimeSpan _tooManyRequestsDuring;
    private DateTime? _firstRequest = null;

    public TooManyRequestsOnWriteCollectionDecorator(IMongoCollection<T> collection, TimeSpan tooManyRequestsDuring)
    {
        _collection = collection;
        _tooManyRequestsDuring = tooManyRequestsDuring;
    }

    private void CheckTimout()
    {
        if (_firstRequest is null)
        {
            _firstRequest = DateTime.Now;

            var dns = new DnsEndPoint("localhost", 27017);
            var cluster = _collection.Database.Client.Cluster.ClusterId;
            var server = new ServerId(cluster, dns);
            var connection = new ConnectionId(server);

            var result = new BsonDocument();
            result["code"] = 16500;
            result["errmsg"] = $"{Guid.NewGuid()} RetryAfterMs={_tooManyRequestsDuring.TotalMilliseconds} {Guid.NewGuid()}";

            throw new MongoCommandException(connection, "", new BsonDocument(), result);
        }

        if (DateTime.Now - _firstRequest < _tooManyRequestsDuring)
        {
            throw new Exception("cool it, mate");
        }
    }

    public IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Aggregate(pipeline, options, cancellationToken);
    }

    public IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline,
        AggregateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Aggregate(session, pipeline, options, cancellationToken);
    }

    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.AggregateAsync(pipeline, options, cancellationToken);
    }

    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline, AggregateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.AggregateAsync(session, pipeline, options, cancellationToken);
    }

    public void AggregateToCollection<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.AggregateToCollection(pipeline, options, cancellationToken);
    }

    public void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline,
        AggregateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.AggregateToCollection(session, pipeline, options, cancellationToken);
    }

    public Task AggregateToCollectionAsync<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.AggregateToCollectionAsync(pipeline, options, cancellationToken);
    }

    public Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline,
        AggregateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
    }

    public BulkWriteResult<T> BulkWrite(IEnumerable<WriteModel<T>> requests, BulkWriteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.BulkWrite(requests, options, cancellationToken);
    }

    public BulkWriteResult<T> BulkWrite(IClientSessionHandle session, IEnumerable<WriteModel<T>> requests, BulkWriteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.BulkWrite(session, requests, options, cancellationToken);
    }

    public Task<BulkWriteResult<T>> BulkWriteAsync(IEnumerable<WriteModel<T>> requests, BulkWriteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.BulkWriteAsync(requests, options, cancellationToken);
    }

    public Task<BulkWriteResult<T>> BulkWriteAsync(IClientSessionHandle session, IEnumerable<WriteModel<T>> requests, BulkWriteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.BulkWriteAsync(session, requests, options, cancellationToken);
    }

    public long Count(FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Count(filter, options, cancellationToken);
    }

    public long Count(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Count(session, filter, options, cancellationToken);
    }

    public Task<long> CountAsync(FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountAsync(filter, options, cancellationToken);
    }

    public Task<long> CountAsync(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountAsync(session, filter, options, cancellationToken);
    }

    public long CountDocuments(FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountDocuments(filter, options, cancellationToken);
    }

    public long CountDocuments(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountDocuments(session, filter, options, cancellationToken);
    }

    public Task<long> CountDocumentsAsync(FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountDocumentsAsync(filter, options, cancellationToken);
    }

    public Task<long> CountDocumentsAsync(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.CountDocumentsAsync(session, filter, options, cancellationToken);
    }

    public DeleteResult DeleteMany(FilterDefinition<T> filter, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteMany(filter, cancellationToken);
    }

    public DeleteResult DeleteMany(FilterDefinition<T> filter, DeleteOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteMany(filter, options, cancellationToken);
    }

    public DeleteResult DeleteMany(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteMany(session, filter, options, cancellationToken);
    }

    public Task<DeleteResult> DeleteManyAsync(FilterDefinition<T> filter, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteManyAsync(filter, cancellationToken);
    }

    public Task<DeleteResult> DeleteManyAsync(FilterDefinition<T> filter, DeleteOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteManyAsync(filter, options, cancellationToken);
    }

    public Task<DeleteResult> DeleteManyAsync(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteManyAsync(session, filter, options, cancellationToken);
    }

    public DeleteResult DeleteOne(FilterDefinition<T> filter, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOne(filter, cancellationToken);
    }

    public DeleteResult DeleteOne(FilterDefinition<T> filter, DeleteOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOne(filter, options, cancellationToken);
    }

    public DeleteResult DeleteOne(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOne(session, filter, options, cancellationToken);
    }

    public Task<DeleteResult> DeleteOneAsync(FilterDefinition<T> filter, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOneAsync(filter, cancellationToken);
    }

    public Task<DeleteResult> DeleteOneAsync(FilterDefinition<T> filter, DeleteOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOneAsync(filter, options, cancellationToken);
    }

    public Task<DeleteResult> DeleteOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.DeleteOneAsync(session, filter, options, cancellationToken);
    }

    public IAsyncCursor<TField> Distinct<TField>(FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Distinct(field, filter, options, cancellationToken);
    }

    public IAsyncCursor<TField> Distinct<TField>(IClientSessionHandle session, FieldDefinition<T, TField> field, FilterDefinition<T> filter,
        DistinctOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Distinct(session, field, filter, options, cancellationToken);
    }

    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.DistinctAsync(field, filter, options, cancellationToken);
    }

    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(IClientSessionHandle session, FieldDefinition<T, TField> field, FilterDefinition<T> filter,
        DistinctOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.DistinctAsync(session, field, filter, options, cancellationToken);
    }

    public long EstimatedDocumentCount(EstimatedDocumentCountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.EstimatedDocumentCount(options, cancellationToken);
    }

    public Task<long> EstimatedDocumentCountAsync(EstimatedDocumentCountOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.EstimatedDocumentCountAsync(options, cancellationToken);
    }

    public IAsyncCursor<TProjection> FindSync<TProjection>(FilterDefinition<T> filter, FindOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.FindSync(filter, options, cancellationToken);
    }

    public IAsyncCursor<TProjection> FindSync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.FindSync(session, filter, options, cancellationToken);
    }

    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(FilterDefinition<T> filter, FindOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.FindAsync(filter, options, cancellationToken);
    }

    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.FindAsync(session, filter, options, cancellationToken);
    }

    public TProjection FindOneAndDelete<TProjection>(FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndDelete(filter, options, cancellationToken);
    }

    public TProjection FindOneAndDelete<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter,
        FindOneAndDeleteOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndDelete(session, filter, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndDeleteAsync(filter, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter,
        FindOneAndDeleteOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndDeleteAsync(session, filter, options, cancellationToken);
    }

    public TProjection FindOneAndReplace<TProjection>(FilterDefinition<T> filter, T replacement,
        FindOneAndReplaceOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndReplace(filter, replacement, options, cancellationToken);
    }

    public TProjection FindOneAndReplace<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, T replacement,
        FindOneAndReplaceOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndReplace(session, filter, replacement, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(FilterDefinition<T> filter, T replacement,
        FindOneAndReplaceOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndReplaceAsync(filter, replacement, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, T replacement,
        FindOneAndReplaceOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndReplaceAsync(session, filter, replacement, options, cancellationToken);
    }

    public TProjection FindOneAndUpdate<TProjection>(FilterDefinition<T> filter, UpdateDefinition<T> update,
        FindOneAndUpdateOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndUpdate(filter, update, options, cancellationToken);
    }

    public TProjection FindOneAndUpdate<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter,
        UpdateDefinition<T> update, FindOneAndUpdateOptions<T, TProjection> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndUpdate(session, filter, update, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(FilterDefinition<T> filter, UpdateDefinition<T> update,
        FindOneAndUpdateOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndUpdateAsync(filter, update, options, cancellationToken);
    }

    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update,
        FindOneAndUpdateOptions<T, TProjection> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.FindOneAndUpdateAsync(session, filter, update, options, cancellationToken);
    }

    public void InsertOne(T document, InsertOneOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.InsertOne(document, options, cancellationToken);
    }

    public void InsertOne(IClientSessionHandle session, T document, InsertOneOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.InsertOne(session, document, options, cancellationToken);
    }

    public Task InsertOneAsync(T document, CancellationToken _cancellationToken)
    {
        CheckTimout();

        return _collection.InsertOneAsync(document, _cancellationToken);
    }

    public Task InsertOneAsync(T document, InsertOneOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.InsertOneAsync(document, options, cancellationToken);
    }

    public Task InsertOneAsync(IClientSessionHandle session, T document, InsertOneOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.InsertOneAsync(session, document, options, cancellationToken);
    }

    public void InsertMany(IEnumerable<T> documents, InsertManyOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.InsertMany(documents, options, cancellationToken);
    }

    public void InsertMany(IClientSessionHandle session, IEnumerable<T> documents, InsertManyOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        _collection.InsertMany(session, documents, options, cancellationToken);
    }

    public Task InsertManyAsync(IEnumerable<T> documents, InsertManyOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.InsertManyAsync(documents, options, cancellationToken);
    }

    public Task InsertManyAsync(IClientSessionHandle session, IEnumerable<T> documents, InsertManyOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.InsertManyAsync(session, documents, options, cancellationToken);
    }

    public IAsyncCursor<TResult> MapReduce<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.MapReduce(map, reduce, options, cancellationToken);
    }

    public IAsyncCursor<TResult> MapReduce<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce,
        MapReduceOptions<T, TResult> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.MapReduce(session, map, reduce, options, cancellationToken);
    }

    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult> options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.MapReduceAsync(map, reduce, options, cancellationToken);
    }

    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce,
        MapReduceOptions<T, TResult> options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.MapReduceAsync(session, map, reduce, options, cancellationToken);
    }

    public IFilteredMongoCollection<TDerivedDocument> OfType<TDerivedDocument>() where TDerivedDocument : T
    {
        return _collection.OfType<TDerivedDocument>();
    }

    public ReplaceOneResult ReplaceOne(FilterDefinition<T> filter, T replacement, ReplaceOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
    }

    public ReplaceOneResult ReplaceOne(FilterDefinition<T> filter, T replacement, UpdateOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOne(filter, replacement, options, cancellationToken);
    }

    public ReplaceOneResult ReplaceOne(IClientSessionHandle session, FilterDefinition<T> filter, T replacement,
        ReplaceOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
    }

    public ReplaceOneResult ReplaceOne(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, UpdateOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
    }

    public Task<ReplaceOneResult> ReplaceOneAsync(FilterDefinition<T> filter, T replacement, ReplaceOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
    }

    public Task<ReplaceOneResult> ReplaceOneAsync(FilterDefinition<T> filter, T replacement, UpdateOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
    }

    public Task<ReplaceOneResult> ReplaceOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, T replacement,
        ReplaceOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
    }

    public Task<ReplaceOneResult> ReplaceOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, UpdateOptions options,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
    }

    public UpdateResult UpdateMany(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateMany(filter, update, options, cancellationToken);
    }

    public UpdateResult UpdateMany(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update,
        UpdateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateMany(session, filter, update, options, cancellationToken);
    }

    public Task<UpdateResult> UpdateManyAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateManyAsync(filter, update, options, cancellationToken);
    }

    public Task<UpdateResult> UpdateManyAsync(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update,
        UpdateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateManyAsync(session, filter, update, options, cancellationToken);
    }

    public UpdateResult UpdateOne(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateOne(filter, update, options, cancellationToken);
    }

    public UpdateResult UpdateOne(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update,
        UpdateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateOne(session, filter, update, options, cancellationToken);
    }

    public Task<UpdateResult> UpdateOneAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateOneAsync(filter, update, options, cancellationToken);
    }

    public Task<UpdateResult> UpdateOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update,
        UpdateOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        CheckTimout();

        return _collection.UpdateOneAsync(session, filter, update, options, cancellationToken);
    }

    public IChangeStreamCursor<TResult> Watch<TResult>(PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Watch(pipeline, options, cancellationToken);
    }

    public IChangeStreamCursor<TResult> Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline,
        ChangeStreamOptions options = null, CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.Watch(session, pipeline, options, cancellationToken);
    }

    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.WatchAsync(pipeline, options, cancellationToken);
    }

    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions options = null,
        CancellationToken cancellationToken = new CancellationToken())
    {
        return _collection.WatchAsync(session, pipeline, options, cancellationToken);
    }

    public IMongoCollection<T> WithReadConcern(ReadConcern readConcern)
    {
        return _collection.WithReadConcern(readConcern);
    }

    public IMongoCollection<T> WithReadPreference(ReadPreference readPreference)
    {
        return _collection.WithReadPreference(readPreference);
    }

    public IMongoCollection<T> WithWriteConcern(WriteConcern writeConcern)
    {
        return _collection.WithWriteConcern(writeConcern);
    }

    public CollectionNamespace CollectionNamespace => _collection.CollectionNamespace;

    public IMongoDatabase Database => _collection.Database;

    public IBsonSerializer<T> DocumentSerializer => _collection.DocumentSerializer;

    public IMongoIndexManager<T> Indexes => _collection.Indexes;

    public MongoCollectionSettings Settings => _collection.Settings;
}