// 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;
}
}
