// static constructor static AggregateFluentBucketTests() { var databaseNamespace = DriverTestConfiguration.DatabaseNamespace; __database = DriverTestConfiguration.Client.GetDatabase(databaseNamespace.DatabaseName); __collectionNamespace = DriverTestConfiguration.CollectionNamespace; __ensureTestData = new Lazy<bool>(CreateTestData); }
// constructors public BulkDeleteOperationEmulator( CollectionNamespace collectionNamespace, IEnumerable<DeleteRequest> requests, MessageEncoderSettings messageEncoderSettings) : base(collectionNamespace, requests, messageEncoderSettings) { }
// constructors public BulkUpdateOperation( CollectionNamespace collectionNamespace, IEnumerable<UpdateRequest> requests, MessageEncoderSettings messageEncoderSettings) : base(collectionNamespace, requests, messageEncoderSettings) { }
// constructors /// <summary> /// Initializes a new instance of the <see cref="MapReduceOperationBase"/> class. /// </summary> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="mapFunction">The map function.</param> /// <param name="reduceFunction">The reduce function.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> protected MapReduceOperationBase(CollectionNamespace collectionNamespace, BsonJavaScript mapFunction, BsonJavaScript reduceFunction, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _mapFunction = Ensure.IsNotNull(mapFunction, nameof(mapFunction)); _reduceFunction = Ensure.IsNotNull(reduceFunction, nameof(reduceFunction)); _messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, nameof(messageEncoderSettings)); }
public void Setup() { _collectionNamespace = new CollectionNamespace("foo", "bar"); _fieldName = "a.b"; _messageEncoderSettings = new MessageEncoderSettings(); _valueSerializer = new Int32Serializer(); }
// static constructor static DriverTestConfiguration() { var connectionString = CoreTestConfiguration.ConnectionString.ToString(); var mongoUrl = new MongoUrl(connectionString); var clientSettings = MongoClientSettings.FromUrl(mongoUrl); if (!clientSettings.WriteConcern.IsAcknowledged) { clientSettings.WriteConcern = WriteConcern.Acknowledged; // ensure WriteConcern is enabled regardless of what the URL says } var serverSelectionTimeoutString = Environment.GetEnvironmentVariable("MONGO_SERVER_SELECTION_TIMEOUT_MS"); if (serverSelectionTimeoutString == null) { serverSelectionTimeoutString = "10000"; } clientSettings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(int.Parse(serverSelectionTimeoutString)); clientSettings.ClusterConfigurator = cb => { var traceSource = new TraceSource("mongodb-tests", SourceLevels.Information); traceSource.Listeners.Clear(); // remove the default listener var listener = new ConsoleTraceListener(); traceSource.Listeners.Add(listener); cb.TraceWith(traceSource); }; __client = new MongoClient(clientSettings); __databaseNamespace = mongoUrl.DatabaseName == null ? CoreTestConfiguration.DatabaseNamespace : new DatabaseNamespace(mongoUrl.DatabaseName); __collectionNamespace = new CollectionNamespace(__databaseNamespace, "testcollection"); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="QueryMessage"/> class. /// </summary> /// <param name="requestId">The request identifier.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="query">The query.</param> /// <param name="fields">The fields.</param> /// <param name="queryValidator">The query validator.</param> /// <param name="skip">The number of documents to skip.</param> /// <param name="batchSize">The size of a batch.</param> /// <param name="slaveOk">if set to <c>true</c> it is OK if the server is not the primary.</param> /// <param name="partialOk">if set to <c>true</c> the server is allowed to return partial results if any shards are unavailable.</param> /// <param name="noCursorTimeout">if set to <c>true</c> the server should not timeout the cursor.</param> /// <param name="oplogReplay">if set to <c>true</c> the OplogReplay bit will be set.</param> /// <param name="tailableCursor">if set to <c>true</c> the query should return a tailable cursor.</param> /// <param name="awaitData">if set to <c>true</c> the server should await data (used with tailable cursors).</param> /// <param name="shouldBeSent">A delegate that determines whether this message should be sent.</param> public QueryMessage( int requestId, CollectionNamespace collectionNamespace, BsonDocument query, BsonDocument fields, IElementNameValidator queryValidator, int skip, int batchSize, bool slaveOk, bool partialOk, bool noCursorTimeout, bool oplogReplay, bool tailableCursor, bool awaitData, Func<bool> shouldBeSent = null) : base(requestId, shouldBeSent) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _query = Ensure.IsNotNull(query, nameof(query)); _fields = fields; // can be null _queryValidator = Ensure.IsNotNull(queryValidator, nameof(queryValidator)); _skip = Ensure.IsGreaterThanOrEqualToZero(skip, nameof(skip)); _batchSize = batchSize; // can be negative _slaveOk = slaveOk; _partialOk = partialOk; _noCursorTimeout = noCursorTimeout; _oplogReplay = oplogReplay; _tailableCursor = tailableCursor; _awaitData = awaitData; }
// constructors protected MapReduceOperationBase(CollectionNamespace collectionNamespace, BsonJavaScript mapFunction, BsonJavaScript reduceFunction, BsonDocument query, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _mapFunction = Ensure.IsNotNull(mapFunction, "mapFunction"); _reduceFunction = Ensure.IsNotNull(reduceFunction, "reduceFunction"); _query = query; _messageEncoderSettings = messageEncoderSettings; }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); // override this database and collection using special ones for this... _databaseNamespace = new DatabaseNamespace("DatabaseExistsOperationTests"); _collectionNamespace = new CollectionNamespace(_databaseNamespace, "DatabaseExistsOperationTests"); }
// constructors public DeleteOpcodeOperationEmulator( CollectionNamespace collectionNamespace, BsonDocument criteria, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _criteria = Ensure.IsNotNull(criteria, "criteria"); _messageEncoderSettings = messageEncoderSettings; }
// constructors public UpdateOpcodeOperationEmulator( CollectionNamespace collectionNamespace, UpdateRequest request, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _request = Ensure.IsNotNull(request, "request"); _messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, "messageEncoderSettings"); }
// constructors protected BulkUnmixedWriteOperationEmulatorBase( CollectionNamespace collectionNamespace, IEnumerable<WriteRequest> requests, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _requests = Ensure.IsNotNull(requests, nameof(requests)); _messageEncoderSettings = messageEncoderSettings; }
// constructors public UpdateOpcodeOperationEmulator( CollectionNamespace collectionNamespace, UpdateRequest request, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _request = Ensure.IsNotNull(request, nameof(request)); _messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, nameof(messageEncoderSettings)); }
// constructors protected AggregateOperationBase( CollectionNamespace collectionNamespace, IEnumerable<BsonDocument> pipeline, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _pipeline = Ensure.IsNotNull(pipeline, "pipeline").ToList(); _messageEncoderSettings = messageEncoderSettings; }
// constructors public DeleteWireProtocol( CollectionNamespace collectionNamespace, BsonDocument query, bool isMulti, MessageEncoderSettings messageEncoderSettings, WriteConcern writeConcern) : base(collectionNamespace, messageEncoderSettings, writeConcern) { _query = Ensure.IsNotNull(query, "query"); _isMulti = isMulti; }
// constructors /// <summary> /// Initializes a new instance of the <see cref="DeleteMessage"/> class. /// </summary> /// <param name="requestId">The request identifier.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="query">The query.</param> /// <param name="isMulti">if set to <c>true</c> [is multi].</param> public DeleteMessage( int requestId, CollectionNamespace collectionNamespace, BsonDocument query, bool isMulti) : base(requestId) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _query = Ensure.IsNotNull(query, "query"); _isMulti = isMulti; }
// constructors /// <summary> /// Initializes a new instance of the <see cref="GetMoreMessage"/> class. /// </summary> /// <param name="requestId">The request identifier.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="cursorId">The cursor identifier.</param> /// <param name="batchSize">The size of a batch.</param> public GetMoreMessage( int requestId, CollectionNamespace collectionNamespace, long cursorId, int batchSize) : base(requestId) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _cursorId = cursorId; _batchSize = Ensure.IsGreaterThanOrEqualToZero(batchSize, "batchSize"); }
// constructors public UpdateOpcodeOperationEmulator( CollectionNamespace collectionNamespace, BsonDocument query, BsonDocument update, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _criteria = Ensure.IsNotNull(query, "criteria"); _update = Ensure.IsNotNull(update, "update"); _messageEncoderSettings = messageEncoderSettings; }
public void CollectionNamespace_should_get_value( [Values("a", "b")] string collectionName) { var collectionNamespace = new CollectionNamespace(_collectionNamespace.DatabaseNamespace, collectionName); var subject = new FakeMapReduceOperation(collectionNamespace, _mapFunction, _reduceFunction, _messageEncoderSettings); var result = subject.CollectionNamespace; result.Should().BeSameAs(collectionNamespace); }
public void constructor_with_key_should_throw_when_key_is_null() { var collectionNamespace = new CollectionNamespace("databaseName", "collectionName"); var initial = new BsonDocument("x", 1); var reduceFunction = new BsonJavaScript("reduceFunction"); var filter = new BsonDocument("y", 1); var messageEncoderSettings = new MessageEncoderSettings(); Action action = () => new GroupOperation<BsonDocument>(collectionNamespace, (BsonDocument)null, initial, reduceFunction, filter, messageEncoderSettings); action.ShouldThrow<ArgumentNullException>(); }
public void CollectionNamespace_get_should_return_expected_result( [Values("a", "b")] string collectionName) { var databaseNamespace = new DatabaseNamespace("test"); var collectionNamespace = new CollectionNamespace(databaseNamespace, collectionName); var subject = new FindOpcodeOperation<BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings); var result = subject.CollectionNamespace; result.Should().Be(collectionNamespace); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="UpdateMessage"/> class. /// </summary> /// <param name="requestId">The request identifier.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="query">The query.</param> /// <param name="update">The update.</param> /// <param name="updateValidator">The update validator.</param> /// <param name="isMulti">if set to <c>true</c> all matching documents should be updated.</param> /// <param name="isUpsert">if set to <c>true</c> a document should be inserted if no matching document is found.</param> public UpdateMessage( int requestId, CollectionNamespace collectionNamespace, BsonDocument query, BsonDocument update, IElementNameValidator updateValidator, bool isMulti, bool isUpsert) : base(requestId) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _query = Ensure.IsNotNull(query, nameof(query)); _update = Ensure.IsNotNull(update, nameof(update)); _updateValidator = Ensure.IsNotNull(updateValidator, nameof(updateValidator)); _isMulti = isMulti; _isUpsert = isUpsert; }
// static constructor static DriverTestConfiguration() { var connectionString = CoreTestConfiguration.ConnectionString.ToString(); var clientSettings = MongoClientSettings.FromUrl(new MongoUrl(connectionString)); var serverSelectionTimeoutString = Environment.GetEnvironmentVariable("MONGO_SERVER_SELECTION_TIMEOUT_MS"); if (serverSelectionTimeoutString == null) { serverSelectionTimeoutString = "30000"; } clientSettings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(int.Parse(serverSelectionTimeoutString)); clientSettings.ClusterConfigurator = cb => CoreTestConfiguration.ConfigureLogging(cb); __client = new Lazy<MongoClient>(() => new MongoClient(clientSettings), true); __databaseNamespace = CoreTestConfiguration.DatabaseNamespace; __collectionNamespace = new CollectionNamespace(__databaseNamespace, "testcollection"); }
// constructors public UpdateWireProtocol( CollectionNamespace collectionNamespace, MessageEncoderSettings messageEncoderSettings, WriteConcern writeConcern, BsonDocument query, BsonDocument update, IElementNameValidator updateValidator, bool isMulti, bool isUpsert) : base(collectionNamespace, messageEncoderSettings, writeConcern) { _updateValidator = Ensure.IsNotNull(updateValidator, nameof(updateValidator)); _query = Ensure.IsNotNull(query, nameof(query)); _update = Ensure.IsNotNull(update, nameof(update)); _isMulti = isMulti; _isUpsert = isUpsert; }
// static constructor static DriverTestConfiguration() { var connectionString = CoreTestConfiguration.ConnectionString.ToString(); var mongoUrl = new MongoUrl(connectionString); var clientSettings = MongoClientSettings.FromUrl(mongoUrl); if (!clientSettings.WriteConcern.IsAcknowledged) { clientSettings.WriteConcern = WriteConcern.Acknowledged; // ensure WriteConcern is enabled regardless of what the URL says } clientSettings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(500); __client = new MongoClient(clientSettings); __databaseNamespace = mongoUrl.DatabaseName == null ? CoreTestConfiguration.DatabaseNamespace : new DatabaseNamespace(mongoUrl.DatabaseName); __collectionNamespace = new CollectionNamespace(__databaseNamespace, "testcollection"); }
public void constructor_should_initialize_instance() { var channelSource = Substitute.For<IChannelSource>(); var databaseNamespace = new DatabaseNamespace("test"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "test"); var query = new BsonDocument("x", 1); var firstBatch = new BsonDocument[] { new BsonDocument("y", 2) }; var cursorId = 1L; var batchSize = 2; var limit = 3; var serializer = BsonDocumentSerializer.Instance; var messageEncoderSettings = new MessageEncoderSettings(); var maxTime = TimeSpan.FromSeconds(1); var result = new AsyncCursor<BsonDocument>( channelSource, collectionNamespace, query, firstBatch, cursorId, batchSize, limit, serializer, messageEncoderSettings, maxTime); var reflector = new Reflector(result); reflector.BatchSize.Should().Be(batchSize); reflector.ChannelSource.Should().Be(channelSource); reflector.CollectionNamespace.Should().Be(collectionNamespace); reflector.Count.Should().Be(firstBatch.Length); reflector.CurrentBatch.Should().BeNull(); reflector.CursorId.Should().Be(cursorId); reflector.Disposed.Should().BeFalse(); reflector.FirstBatch.Should().Equal(firstBatch); reflector.Limit.Should().Be(limit); reflector.MaxTime.Should().Be(maxTime); reflector.MessageEncoderSettings.Should().BeEquivalentTo(messageEncoderSettings); reflector.Query.Should().Be(query); reflector.Serializer.Should().Be(serializer); }
public void constructor_with_key_should_initialize_subject() { var collectionNamespace = new CollectionNamespace("databaseName", "collectionName"); var key = new BsonDocument("key", 1); var initial = new BsonDocument("x", 1); var reduceFunction = new BsonJavaScript("reduceFunction"); var filter = new BsonDocument("y", 1); var messageEncoderSettings = new MessageEncoderSettings(); var subject = new GroupOperation<BsonDocument>(collectionNamespace, key, initial, reduceFunction, filter, messageEncoderSettings); subject.CollectionNamespace.Should().Be(collectionNamespace); subject.Filter.Should().Be(filter); subject.FinalizeFunction.Should().BeNull(); subject.Initial.Should().Be(initial); subject.Key.Should().Be(key); subject.KeyFunction.Should().BeNull(); subject.MaxTime.Should().Be(default(TimeSpan?)); Assert.Equal(messageEncoderSettings, subject.MessageEncoderSettings); subject.ReduceFunction.Should().Be(reduceFunction); subject.ResultSerializer.Should().BeNull(); }
// methods /// <summary> /// Reads the message. /// </summary> /// <returns>A message.</returns> public GetMoreMessage ReadMessage() { var binaryReader = CreateBinaryReader(); var stream = binaryReader.BsonStream; stream.ReadInt32(); // messageSize var requestId = stream.ReadInt32(); stream.ReadInt32(); // responseTo var opcode = (Opcode)stream.ReadInt32(); EnsureOpcodeIsValid(opcode); stream.ReadInt32(); // reserved var fullCollectionName = stream.ReadCString(Encoding); var batchSize = stream.ReadInt32(); var cursorId = stream.ReadInt64(); return(new GetMoreMessage( requestId, CollectionNamespace.FromFullName(fullCollectionName), cursorId, batchSize)); }
public Task <WriteConcernResult> UpdateAsync( CollectionNamespace collectionNamespace, MessageEncoderSettings messageEncoderSettings, WriteConcern writeConcern, BsonDocument query, BsonDocument update, IElementNameValidator updateValidator, bool isMulti, bool isUpsert, CancellationToken cancellationToken) { var protocol = new UpdateWireProtocol( collectionNamespace, messageEncoderSettings, writeConcern, query, update, updateValidator, isMulti, isUpsert); return(ExecuteProtocolAsync(protocol, cancellationToken)); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="AsyncCursor{TDocument}"/> class. /// </summary> /// <param name="channelSource">The channel source.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="firstBatch">The first batch.</param> /// <param name="cursorId">The cursor identifier.</param> /// <param name="batchSize">The size of a batch.</param> /// <param name="limit">The limit.</param> /// <param name="serializer">The serializer.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> /// <param name="maxTime">The maxTime for each batch.</param> public AsyncCursor( IChannelSource channelSource, CollectionNamespace collectionNamespace, IReadOnlyList <TDocument> firstBatch, long cursorId, int?batchSize, int?limit, IBsonSerializer <TDocument> serializer, MessageEncoderSettings messageEncoderSettings, TimeSpan?maxTime = null) : this( channelSource, collectionNamespace, firstBatch, cursorId, null, // postBatchResumeToken batchSize, limit, serializer, messageEncoderSettings, maxTime) { }
private AutoEncryptionOptions CreateSubject( SslSettings tlsOptions = null, string tlsKey = "test", CollectionNamespace collectionNamespace = null, Dictionary <string, BsonDocument> schemaMap = null, Dictionary <string, BsonDocument> encryptedFieldsMap = null, Dictionary <string, object> extraOptions = null) { var autoEncryptionOptions = new AutoEncryptionOptions( keyVaultNamespace: collectionNamespace ?? __keyVaultNamespace, kmsProviders: GetKmsProviders(), schemaMap: schemaMap, encryptedFieldsMap: encryptedFieldsMap, extraOptions: extraOptions); if (tlsOptions != null) { autoEncryptionOptions = autoEncryptionOptions.With(tlsOptions: new Dictionary <string, SslSettings> { { tlsKey, tlsOptions } }); } return(autoEncryptionOptions); }
public DeleteMessage ReadMessage() { var binaryReader = CreateBinaryReader(); var streamReader = binaryReader.StreamReader; var messageSize = streamReader.ReadInt32(); var requestId = streamReader.ReadInt32(); var responseTo = streamReader.ReadInt32(); var opcode = (Opcode)streamReader.ReadInt32(); var reserved = streamReader.ReadInt32(); var fullCollectionName = streamReader.ReadCString(); var flags = (DeleteFlags)streamReader.ReadInt32(); var context = BsonDeserializationContext.CreateRoot <BsonDocument>(binaryReader); var query = BsonDocumentSerializer.Instance.Deserialize(context); var isMulti = !flags.HasFlag(DeleteFlags.Single); return(new DeleteMessage( requestId, CollectionNamespace.FromFullName(fullCollectionName), query, isMulti)); }
public void CreateCommand_should_return_expected_result_when_keyFunction_was_provided() { var collectionNamespace = new CollectionNamespace("databaseName", "collectionName"); var keyFunction = new BsonJavaScript("keyFunction"); var initial = new BsonDocument("x", 1); var reduceFunction = new BsonJavaScript("reduceFunction"); var messageEncoderSettings = new MessageEncoderSettings(); var subject = new GroupOperation <BsonDocument>(collectionNamespace, keyFunction, initial, reduceFunction, null, messageEncoderSettings); var expectedResult = new BsonDocument { { "group", new BsonDocument { { "ns", collectionNamespace.CollectionName }, { "$keyf", keyFunction }, { "$reduce", reduceFunction }, { "initial", initial } } } }; var result = subject.CreateCommand(); result.Should().Be(expectedResult); }
internal static IWriteOperation <BsonDocument> CreateEncryptedCreateCollectionOperationIfConfigured( CollectionNamespace collectionNamespace, BsonDocument encryptedFields, MessageEncoderSettings messageEncoderSettings, Action <CreateCollectionOperation> createCollectionOperationConfigurator) { var mainOperation = new CreateCollectionOperation( collectionNamespace, messageEncoderSettings) { EncryptedFields = encryptedFields }; createCollectionOperationConfigurator?.Invoke(mainOperation); if (encryptedFields != null) { return(new CompositeWriteOperation <BsonDocument>( (CreateInnerCollectionOperation(EncryptedCollectionHelper.GetAdditionalCollectionName(encryptedFields, collectionNamespace, HelperCollectionForEncryption.Esc)), IsMainOperation: false), (CreateInnerCollectionOperation(EncryptedCollectionHelper.GetAdditionalCollectionName(encryptedFields, collectionNamespace, HelperCollectionForEncryption.Ecc)), IsMainOperation: false), (CreateInnerCollectionOperation(EncryptedCollectionHelper.GetAdditionalCollectionName(encryptedFields, collectionNamespace, HelperCollectionForEncryption.Ecos)), IsMainOperation: false), (mainOperation, IsMainOperation: true), (new CreateIndexesOperation(collectionNamespace, new[] { new CreateIndexRequest(EncryptedCollectionHelper.AdditionalCreateIndexDocument) }, messageEncoderSettings), IsMainOperation: false))); } else { return(mainOperation); } CreateCollectionOperation CreateInnerCollectionOperation(string collectionName) => new CreateCollectionOperation(new CollectionNamespace(collectionNamespace.DatabaseNamespace.DatabaseName, collectionName), messageEncoderSettings) { ClusteredIndex = new BsonDocument { { "key", new BsonDocument("_id", 1) }, { "unique", true } } }; }
public void CreateChangeStreamOperation_for_collection_returns_expected_result() { var databaseNamespace = new DatabaseNamespace("databaseName"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "collectionName"); var mockCollection = new Mock <IMongoCollection <BsonDocument> >(); mockCollection.SetupGet(m => m.CollectionNamespace).Returns(collectionNamespace); var pipeline = new EmptyPipelineDefinition <ChangeStreamDocument <BsonDocument> >().Limit(1); var documentSerializer = BsonDocumentSerializer.Instance; var options = new ChangeStreamOptions { BatchSize = 123, Collation = new Collation("en-us"), FullDocument = ChangeStreamFullDocumentOption.UpdateLookup, MaxAwaitTime = TimeSpan.FromSeconds(123), ResumeAfter = new BsonDocument(), StartAtOperationTime = new BsonTimestamp(1, 2) }; var readConcern = new ReadConcern(); var messageEncoderSettings = new MessageEncoderSettings(); var renderedPipeline = RenderPipeline(pipeline); var result = ChangeStreamHelper.CreateChangeStreamOperation(mockCollection.Object, pipeline, documentSerializer, options, readConcern, messageEncoderSettings); result.BatchSize.Should().Be(options.BatchSize); result.Collation.Should().BeSameAs(options.Collation); result.CollectionNamespace.Should().BeSameAs(collectionNamespace); result.DatabaseNamespace.Should().BeNull(); result.FullDocument.Should().Be(options.FullDocument); result.MaxAwaitTime.Should().Be(options.MaxAwaitTime); result.MessageEncoderSettings.Should().BeSameAs(messageEncoderSettings); result.Pipeline.Should().Equal(renderedPipeline.Documents); result.ReadConcern.Should().BeSameAs(readConcern); result.ResultSerializer.Should().BeOfType <ChangeStreamDocumentSerializer <BsonDocument> >(); result.ResumeAfter.Should().BeSameAs(options.ResumeAfter); result.StartAtOperationTime.Should().BeSameAs(options.StartAtOperationTime); }
public override AggregateResult Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var reader = context.Reader; var result = new AggregateResult(); reader.ReadStartDocument(); while (reader.ReadBsonType() != 0) { var elementName = reader.ReadName(); switch (elementName) { case "id": result.CursorId = new Int64Serializer().Deserialize(context); break; case "ns": var ns = reader.ReadString(); result.CollectionNamespace = CollectionNamespace.FromFullName(ns); break; case "firstBatch": var arraySerializer = new ArraySerializer <TResult>(_resultSerializer); result.Results = arraySerializer.Deserialize(context); break; case "postBatchResumeToken": result.PostBatchResumeToken = BsonDocumentSerializer.Instance.Deserialize(context); break; default: reader.SkipValue(); break; } } reader.ReadEndDocument(); return(result); }
public void constructor_should_initialize_instance() { var channelSource = new Mock <IChannelSource>().Object; var databaseNamespace = new DatabaseNamespace("test"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "test"); var firstBatch = new BsonDocument[] { new BsonDocument("y", 2) }; var cursorId = 1L; var batchSize = 2; var limit = 3; var serializer = BsonDocumentSerializer.Instance; var messageEncoderSettings = new MessageEncoderSettings(); var maxTime = TimeSpan.FromSeconds(1); var result = new AsyncCursor <BsonDocument>( channelSource, collectionNamespace, firstBatch, cursorId, batchSize, limit, serializer, messageEncoderSettings, maxTime); result._batchSize().Should().Be(batchSize); result._channelSource().Should().Be(channelSource); result._collectionNamespace().Should().Be(collectionNamespace); result._count().Should().Be(firstBatch.Length); result._currentBatch().Should().BeNull(); result._cursorId().Should().Be(cursorId); result._disposed().Should().BeFalse(); result._firstBatch().Should().Equal(firstBatch); result._limit().Should().Be(limit); result._maxTime().Should().Be(maxTime); result._messageEncoderSettings().Should().BeEquivalentTo(messageEncoderSettings); result._serializer().Should().Be(serializer); }
static void Main(string[] args) { var connectionString = "mongodb://localhost:27017"; var keyVaultNamespace = CollectionNamespace.FromFullName("encryption.__keyVault"); var kmsKeyHelper = new KmsKeyHelper( connectionString: connectionString, keyVaultNamespace: keyVaultNamespace); var autoEncryptionHelper = new AutoEncryptionHelper( connectionString: connectionString, keyVaultNamespace: keyVaultNamespace); string kmsKeyIdBase64; //Only run GenerateLocalMasterKey() once //kmsKeyHelper.GenerateLocalMasterKey(); //Local kmsKeyIdBase64 = kmsKeyHelper.CreateKeyWithLocalKmsProvider(); autoEncryptionHelper.EncryptedWriteAndRead(kmsKeyIdBase64, KmsKeyLocation.Local); // AWS //kmsKeyIdBase64 = kmsKeyHelper.CreateKeyWithAwsKmsProvider(); //autoEncryptionHelper.EncryptedWriteAndRead(kmsKeyIdBase64, KmsKeyLocation.AWS); // Azure //kmsKeyIdBase64 = kmsKeyHelper.CreateKeyWithAzureKmsProvider(); //autoEncryptionHelper.EncryptedWriteAndRead(kmsKeyIdBase64, KmsKeyLocation.Azure); // GCP //kmsKeyIdBase64 = kmsKeyHelper.CreateKeyWithGcpKmsProvider(); //autoEncryptionHelper.EncryptedWriteAndRead(kmsKeyIdBase64, KmsKeyLocation.GCP); autoEncryptionHelper.QueryWithNonEncryptedClient(); Console.ReadKey(); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="AsyncCursor{TDocument}"/> class. /// </summary> /// <param name="channelSource">The channel source.</param> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="query">The query.</param> /// <param name="firstBatch">The first batch.</param> /// <param name="cursorId">The cursor identifier.</param> /// <param name="batchSize">The size of a batch.</param> /// <param name="limit">The limit.</param> /// <param name="serializer">The serializer.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> /// <param name="maxTime">The maxTime for each batch.</param> public AsyncCursor( IChannelSource channelSource, CollectionNamespace collectionNamespace, BsonDocument query, IReadOnlyList <TDocument> firstBatch, long cursorId, int?batchSize, int?limit, IBsonSerializer <TDocument> serializer, MessageEncoderSettings messageEncoderSettings, TimeSpan?maxTime = null) { _operationId = EventContext.OperationId; _channelSource = channelSource; _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _query = Ensure.IsNotNull(query, nameof(query)); _firstBatch = Ensure.IsNotNull(firstBatch, nameof(firstBatch)); _cursorId = cursorId; _batchSize = Ensure.IsNullOrGreaterThanOrEqualToZero(batchSize, nameof(batchSize)); _limit = Ensure.IsNullOrGreaterThanOrEqualToZero(limit, nameof(limit)); _serializer = Ensure.IsNotNull(serializer, nameof(serializer)); _messageEncoderSettings = messageEncoderSettings; _maxTime = maxTime; if (_limit > 0 && _firstBatch.Count > _limit) { _firstBatch = _firstBatch.Take(_limit.Value).ToList(); } _count = _firstBatch.Count; // if we aren't going to need the channel source we can go ahead and Dispose it now if (_cursorId == 0 && _channelSource != null) { _channelSource.Dispose(); _channelSource = null; } }
/// <summary> /// Reads the message. /// </summary> /// <returns>A message.</returns> public InsertMessage <TDocument> ReadMessage() { var binaryReader = CreateBinaryReader(); var stream = binaryReader.BsonStream; var startPosition = stream.Position; var messageSize = stream.ReadInt32(); var requestId = stream.ReadInt32(); stream.ReadInt32(); // responseTo stream.ReadInt32(); // opcode var flags = (InsertFlags)stream.ReadInt32(); var fullCollectionName = stream.ReadCString(Encoding); var documents = new List <TDocument>(); while (stream.Position < startPosition + messageSize) { var context = BsonDeserializationContext.CreateRoot(binaryReader); var document = _serializer.Deserialize(context); documents.Add(document); } var documentSource = new BatchableSource <TDocument>(documents); var maxBatchCount = int.MaxValue; var maxMessageSize = int.MaxValue; var continueOnError = (flags & InsertFlags.ContinueOnError) == InsertFlags.ContinueOnError; return(new InsertMessage <TDocument>( requestId, CollectionNamespace.FromFullName(fullCollectionName), _serializer, documentSource, maxBatchCount, maxMessageSize, continueOnError)); }
public void constructor_with_collection_should_initialize_instance() { var collectionNamespace = new CollectionNamespace(new DatabaseNamespace("foo"), "bar"); var pipeline = new List <BsonDocument> { BsonDocument.Parse("{ $match : { operationType : \"insert\" } }") }; var resultSerializer = BsonDocumentSerializer.Instance; var messageEncoderSettings = new MessageEncoderSettings(); var subject = new ChangeStreamOperation <BsonDocument>(collectionNamespace, pipeline, resultSerializer, messageEncoderSettings); subject.BatchSize.Should().NotHaveValue(); subject.Collation.Should().BeNull(); subject.CollectionNamespace.Should().BeSameAs(collectionNamespace); subject.DatabaseNamespace.Should().BeNull(); subject.FullDocument.Should().Be(ChangeStreamFullDocumentOption.Default); subject.MaxAwaitTime.Should().NotHaveValue(); subject.MessageEncoderSettings.Should().BeSameAs(messageEncoderSettings); subject.Pipeline.Should().Equal(pipeline); subject.ReadConcern.Should().Be(ReadConcern.Default); subject.ResultSerializer.Should().BeSameAs(resultSerializer); subject.ResumeAfter.Should().BeNull(); subject.StartAtOperationTime.Should().BeNull(); }
private async Task <IAsyncCursor <BsonDocument> > ExecuteUsingCommandAsync(IChannelSourceHandle channelSource, ReadPreference readPreference, CancellationToken cancellationToken) { var command = new BsonDocument { { "listCollections", 1 }, { "filter", _filter, _filter != null } }; var operation = new ReadCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); var response = await operation.ExecuteAsync(channelSource, readPreference, cancellationToken).ConfigureAwait(false); var cursorDocument = response["cursor"].AsBsonDocument; var cursor = new AsyncCursor <BsonDocument>( channelSource.Fork(), CollectionNamespace.FromFullName(cursorDocument["ns"].AsString), command, cursorDocument["firstBatch"].AsBsonArray.OfType <BsonDocument>().ToList(), cursorDocument["id"].ToInt64(), 0, 0, BsonDocumentSerializer.Instance, _messageEncoderSettings); return(cursor); }
/// <summary> /// Reads the message. /// </summary> /// <returns>A message.</returns> public DeleteMessage ReadMessage() { var binaryReader = CreateBinaryReader(); var stream = binaryReader.BsonStream; stream.ReadInt32(); // messageSize var requestId = stream.ReadInt32(); stream.ReadInt32(); // responseTo stream.ReadInt32(); // opcode stream.ReadInt32(); // reserved var fullCollectionName = stream.ReadCString(Encoding); var flags = (DeleteFlags)stream.ReadInt32(); var context = BsonDeserializationContext.CreateRoot(binaryReader); var query = BsonDocumentSerializer.Instance.Deserialize(context); var isMulti = (flags & DeleteFlags.Single) != DeleteFlags.Single; return(new DeleteMessage( requestId, CollectionNamespace.FromFullName(fullCollectionName), query, isMulti)); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="AutoEncryptionOptions"/> class. /// </summary> /// <param name="keyVaultNamespace">The keyVault namespace.</param> /// <param name="kmsProviders">The kms providers.</param> /// <param name="bypassAutoEncryption">The bypass auto encryption flag.</param> /// <param name="extraOptions">The extra options.</param> /// <param name="keyVaultClient">The keyVault client.</param> /// <param name="schemaMap">The schema map.</param> /// <param name="tlsOptions">The tls options.</param> /// <param name="encryptedFieldsMap">The encryptedFields map.</param> public AutoEncryptionOptions( CollectionNamespace keyVaultNamespace, IReadOnlyDictionary <string, IReadOnlyDictionary <string, object> > kmsProviders, Optional <bool> bypassAutoEncryption = default, Optional <IReadOnlyDictionary <string, object> > extraOptions = default, Optional <IMongoClient> keyVaultClient = default, Optional <IReadOnlyDictionary <string, BsonDocument> > schemaMap = default, Optional <IReadOnlyDictionary <string, SslSettings> > tlsOptions = default, Optional <IReadOnlyDictionary <string, BsonDocument> > encryptedFieldsMap = default) { _keyVaultNamespace = Ensure.IsNotNull(keyVaultNamespace, nameof(keyVaultNamespace)); _kmsProviders = Ensure.IsNotNull(kmsProviders, nameof(kmsProviders)); _bypassAutoEncryption = bypassAutoEncryption.WithDefault(false); _extraOptions = extraOptions.WithDefault(null); _keyVaultClient = keyVaultClient.WithDefault(null); _schemaMap = schemaMap.WithDefault(null); _tlsOptions = tlsOptions.WithDefault(new Dictionary <string, SslSettings>()); _encryptedFieldsMap = encryptedFieldsMap.WithDefault(null); EncryptionExtraOptionsValidator.EnsureThatExtraOptionsAreValid(_extraOptions); KmsProvidersHelper.EnsureKmsProvidersAreValid(_kmsProviders); KmsProvidersHelper.EnsureKmsProvidersTlsSettingsAreValid(_tlsOptions); EncryptedCollectionHelper.EnsureCollectionsValid(_schemaMap, _encryptedFieldsMap); }
public static QueryMessage BuildQueryMessage( BsonDocument query = null, int requestId = 0, CollectionNamespace collectionNamespace = null) { if (collectionNamespace == null) { collectionNamespace = new CollectionNamespace("foo", "bar"); } return(new QueryMessage( requestId: requestId, collectionNamespace: collectionNamespace, query: query ?? new BsonDocument(), fields: null, queryValidator: NoOpElementNameValidator.Instance, skip: 0, batchSize: 0, slaveOk: false, partialOk: false, noCursorTimeout: false, tailableCursor: false, awaitData: false)); }
// static constructor static DriverTestConfiguration() { var connectionString = CoreTestConfiguration.ConnectionString.ToString(); var mongoUrl = new MongoUrl(connectionString); var clientSettings = MongoClientSettings.FromUrl(mongoUrl); if (!clientSettings.WriteConcern.IsAcknowledged) { clientSettings.WriteConcern = WriteConcern.Acknowledged; // ensure WriteConcern is enabled regardless of what the URL says } var serverSelectionTimeoutString = Environment.GetEnvironmentVariable("MONGO_SERVER_SELECTION_TIMEOUT_MS"); if (serverSelectionTimeoutString == null) { serverSelectionTimeoutString = "10000"; } clientSettings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(int.Parse(serverSelectionTimeoutString)); __client = new MongoClient(clientSettings); __databaseNamespace = mongoUrl.DatabaseName == null ? CoreTestConfiguration.DatabaseNamespace : new DatabaseNamespace(mongoUrl.DatabaseName); __collectionNamespace = new CollectionNamespace(__databaseNamespace, "testcollection"); }
public Task <CursorBatch <TDocument> > QueryAsync <TDocument>( CollectionNamespace collectionNamespace, BsonDocument query, BsonDocument fields, IElementNameValidator queryValidator, int skip, int batchSize, bool slaveOk, bool partialOk, bool noCursorTimeout, bool tailableCursor, bool awaitData, IBsonSerializer <TDocument> serializer, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken) { #pragma warning disable 618 return(QueryAsync( collectionNamespace, query, fields, queryValidator, skip, batchSize, slaveOk, partialOk, noCursorTimeout, oplogReplay: false, tailableCursor, awaitData, serializer, messageEncoderSettings, cancellationToken)); #pragma warning restore 618 }
public Task <CursorBatch <TDocument> > QueryAsync <TDocument>( CollectionNamespace collectionNamespace, BsonDocument query, BsonDocument fields, IElementNameValidator queryValidator, int skip, int batchSize, bool slaveOk, bool partialOk, bool noCursorTimeout, bool oplogReplay, bool tailableCursor, bool awaitData, IBsonSerializer <TDocument> serializer, MessageEncoderSettings messageEncoderSettings, CancellationToken cancellationToken) { slaveOk = GetEffectiveSlaveOk(slaveOk); var protocol = new QueryWireProtocol <TDocument>( collectionNamespace, query, fields, queryValidator, skip, batchSize, slaveOk, partialOk, noCursorTimeout, oplogReplay, tailableCursor, awaitData, serializer, messageEncoderSettings); return(ExecuteProtocolAsync(protocol, cancellationToken)); }
public void GetMore_should_use_same_session( [Values(false, true)] bool async) { var mockChannelSource = new Mock <IChannelSource>(); var channelSource = mockChannelSource.Object; var mockChannel = new Mock <IChannelHandle>(); var channel = mockChannel.Object; var mockSession = new Mock <ICoreSessionHandle>(); var session = mockSession.Object; var databaseNamespace = new DatabaseNamespace("database"); var collectionNamespace = new CollectionNamespace(databaseNamespace, "collection"); var cursorId = 1; var subject = CreateSubject(collectionNamespace: collectionNamespace, cursorId: cursorId, channelSource: Optional.Create(channelSource)); var cancellationToken = new CancellationTokenSource().Token; var connectionDescription = CreateConnectionDescriptionSupportingSession(); mockChannelSource.SetupGet(m => m.Session).Returns(session); mockChannel.SetupGet(m => m.ConnectionDescription).Returns(connectionDescription); var nextBatchBytes = new byte[] { 5, 0, 0, 0, 0 }; var nextBatchSlice = new ByteArrayBuffer(nextBatchBytes, isReadOnly: true); var secondBatch = new BsonDocument { { "cursor", new BsonDocument { { "id", 0 }, { "nextBatch", new RawBsonArray(nextBatchSlice) } } } }; subject.MoveNext(cancellationToken); // skip empty first batch var sameSessionWasUsed = false; if (async) { mockChannelSource.Setup(m => m.GetChannelAsync(cancellationToken)).Returns(Task.FromResult(channel)); mockChannel .Setup(m => m.CommandAsync( session, null, databaseNamespace, It.IsAny <BsonDocument>(), null, NoOpElementNameValidator.Instance, null, null, CommandResponseHandling.Return, It.IsAny <IBsonSerializer <BsonDocument> >(), It.IsAny <MessageEncoderSettings>(), cancellationToken)) .Callback(() => sameSessionWasUsed = true) .Returns(Task.FromResult(secondBatch)); subject.MoveNextAsync(cancellationToken).GetAwaiter().GetResult(); } else { mockChannelSource.Setup(m => m.GetChannel(cancellationToken)).Returns(channel); mockChannel .Setup(m => m.Command( session, null, databaseNamespace, It.IsAny <BsonDocument>(), null, NoOpElementNameValidator.Instance, null, null, CommandResponseHandling.Return, It.IsAny <IBsonSerializer <BsonDocument> >(), It.IsAny <MessageEncoderSettings>(), cancellationToken)) .Callback(() => sameSessionWasUsed = true) .Returns(secondBatch); subject.MoveNext(cancellationToken); } sameSessionWasUsed.Should().BeTrue(); }
// setup methods public override void TestFixtureSetUp() { _databaseNamespace = CoreTestConfiguration.GetDatabaseNamespaceForTestFixture(); _collectionNamespace = new CollectionNamespace(_databaseNamespace, "old"); _newCollectionNamespace = new CollectionNamespace(_databaseNamespace, "new"); }
public void TestFixtureSetUp() { _collectionNamespace = CoreTestConfiguration.GetCollectionNamespaceForTestFixture(); _messageEncoderSettings = CoreTestConfiguration.MessageEncoderSettings; }
// constructors /// <summary> /// Initializes a new instance of the <see cref="AggregateExplainOperation"/> class. /// </summary> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="pipeline">The pipeline.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> public AggregateExplainOperation(CollectionNamespace collectionNamespace, IEnumerable <BsonDocument> pipeline, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _pipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).ToList(); _messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, nameof(messageEncoderSettings)); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="CountOperation"/> class. /// </summary> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> public CountOperation(CollectionNamespace collectionNamespace, MessageEncoderSettings messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); _messageEncoderSettings = Ensure.IsNotNull(messageEncoderSettings, nameof(messageEncoderSettings)); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateOperation{TResult}"/> class. /// </summary> /// <param name="collectionNamespace">The collection namespace.</param> /// <param name="pipeline">The pipeline.</param> /// <param name="resultSerializer">The result value serializer.</param> /// <param name="messageEncoderSettings">The message encoder settings.</param> public AggregateOperation(CollectionNamespace collectionNamespace, IEnumerable <BsonDocument> pipeline, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings) : this(pipeline, resultSerializer, messageEncoderSettings) { _collectionNamespace = Ensure.IsNotNull(collectionNamespace, nameof(collectionNamespace)); }
// public void ClientSideEncryptionAutoEncryptionSettingsTour() public static void Main(string[] args) { var localMasterKey = Convert.FromBase64String(LocalMasterKey); var kmsProviders = new Dictionary <string, IReadOnlyDictionary <string, object> >(); var localKey = new Dictionary <string, object> { { "key", localMasterKey } }; kmsProviders.Add("local", localKey); var keyVaultDB = "keyVault"; var keystore = "__keystore"; var keyVaultNamespace = CollectionNamespace.FromFullName($"{keyVaultDB}.{keystore}"); var keyVaultMongoClient = new MongoClient(); var clientEncryptionSettings = new ClientEncryptionOptions( keyVaultMongoClient, keyVaultNamespace, kmsProviders); var clientEncryption = new ClientEncryption(clientEncryptionSettings); keyVaultMongoClient.GetDatabase(keyVaultDB).DropCollection(keystore); var altKeyName = new[] { "csharpDataKey01" }; var dataKeyOptions = new DataKeyOptions(alternateKeyNames: altKeyName); var dataKeyId = clientEncryption.CreateDataKey("local", dataKeyOptions, CancellationToken.None); var base64DataKeyId = Convert.ToBase64String(GuidConverter.ToBytes(dataKeyId, GuidRepresentation.Standard)); clientEncryption.Dispose(); var collectionNamespace = CollectionNamespace.FromFullName("test.coll"); var schemaMap = $@"{{ properties: {{ SSN: {{ encrypt: {{ keyId: [{{ '$binary' : {{ 'base64' : '{base64DataKeyId}', 'subType' : '04' }} }}], bsonType: 'string', algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }} }} }}, 'bsonType': 'object' }}"; var autoEncryptionSettings = new AutoEncryptionOptions( keyVaultNamespace, kmsProviders, schemaMap: new Dictionary <string, BsonDocument>() { { collectionNamespace.ToString(), BsonDocument.Parse(schemaMap) } }); var clientSettings = new MongoClientSettings { AutoEncryptionOptions = autoEncryptionSettings }; var client = new MongoClient(clientSettings); var database = client.GetDatabase("test"); database.DropCollection("coll"); var collection = database.GetCollection <BsonDocument>("coll"); collection.InsertOne(new BsonDocument("SSN", "123456789")); var result = collection.Find(FilterDefinition <BsonDocument> .Empty).First(); Console.WriteLine(result.ToJson()); }
// private methods private AutoEncryptionOptions ConfigureAutoEncryptionOptions(BsonDocument autoEncryptOpts) { var extraOptions = new Dictionary <string, object>() { { "mongocryptdSpawnPath", GetEnvironmentVariableOrDefaultOrThrowIfNothing("MONGODB_BINARIES", string.Empty) } }; var kmsProviders = new ReadOnlyDictionary <string, IReadOnlyDictionary <string, object> >(new Dictionary <string, IReadOnlyDictionary <string, object> >()); var autoEncryptionOptions = new AutoEncryptionOptions( keyVaultNamespace: __keyVaultCollectionNamespace, kmsProviders: kmsProviders, extraOptions: extraOptions); foreach (var option in autoEncryptOpts.Elements) { switch (option.Name) { case "kmsProviders": kmsProviders = ParseKmsProviders(option.Value.AsBsonDocument); autoEncryptionOptions = autoEncryptionOptions .With(kmsProviders: kmsProviders); break; case "schemaMap": var schemaMaps = new Dictionary <string, BsonDocument>(); var schemaMapsDocument = option.Value.AsBsonDocument; foreach (var schemaMapElement in schemaMapsDocument.Elements) { schemaMaps.Add(schemaMapElement.Name, schemaMapElement.Value.AsBsonDocument); } autoEncryptionOptions = autoEncryptionOptions.With(schemaMap: schemaMaps); break; case "bypassAutoEncryption": autoEncryptionOptions = autoEncryptionOptions.With(bypassAutoEncryption: option.Value.ToBoolean()); break; case "keyVaultNamespace": autoEncryptionOptions = autoEncryptionOptions.With(keyVaultNamespace: CollectionNamespace.FromFullName(option.Value.AsString)); break; default: throw new Exception($"Unexpected auto encryption option {option.Name}."); } } return(autoEncryptionOptions); }
// constructors public RenameCollectionOperationTests() { _databaseNamespace = CoreTestConfiguration.GetDatabaseNamespaceForTestClass(typeof(RenameCollectionOperationTests)); _collectionNamespace = new CollectionNamespace(_databaseNamespace, "old"); _newCollectionNamespace = new CollectionNamespace(_databaseNamespace, "new"); }
// helper methods private void EnsureCollectionDoesNotExist(CollectionNamespace collectionNamespace, bool async) { var operation = new DropCollectionOperation(collectionNamespace, _messageEncoderSettings); ExecuteOperation(operation, async); }
public virtual void OneTimeSetUp() { _databaseNamespace = CoreTestConfiguration.DatabaseNamespace; _collectionNamespace = new CollectionNamespace(_databaseNamespace, GetType().Name); _messageEncoderSettings = CoreTestConfiguration.MessageEncoderSettings; }
private void EnsureCollectionExists(IWriteBinding binding, CollectionNamespace collectionNamespace) { try { var operation = new CreateCollectionOperation(collectionNamespace, _messageEncoderSettings); operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); } catch (MongoCommandException ex) { if (ex.Message == "Command create failed: collection already exists.") { return; } throw; } }