private void ValidateReadConcern(BsonDocument definition)
{
Exception parseException = null;
ReadConcern readConcern = null;
try
{
readConcern = ReadConcern.FromBsonDocument((BsonDocument)definition["readConcern"]);
}
catch (Exception ex)
{
parseException = ex;
}
if (parseException == null)
{
if (!(bool)definition["valid"])
{
throw new AssertionException($"Should be invalid: {definition["readConcern"]}.");
}
var expectedDocument = (BsonDocument)definition["readConcernDocument"];
var document = readConcern.ToBsonDocument();
document.Should().Be(expectedDocument);
readConcern.IsServerDefault.Should().Be((bool)definition["isServerDefault"]);
}
else
{
if ((bool)definition["valid"])
{
throw new AssertionException($"Should be valid: {definition["readConcern"]}.");
}
}
}
private TransactionOptions ParseTransactionOptions(BsonDocument document)
{
ReadConcern readConcern = null;
ReadPreference readPreference = null;
WriteConcern writeConcern = null;
TimeSpan? maxCommitTimeMS = null;
foreach (var element in document)
{
switch (element.Name)
{
case "readConcern":
readConcern = ReadConcern.FromBsonDocument(element.Value.AsBsonDocument);
break;
case "readPreference":
readPreference = ReadPreference.FromBsonDocument(element.Value.AsBsonDocument);
break;
case "writeConcern":
writeConcern = WriteConcern.FromBsonDocument(element.Value.AsBsonDocument);
break;
case "maxCommitTimeMS":
maxCommitTimeMS = TimeSpan.FromMilliseconds(element.Value.ToInt32());
break;
default:
throw new ArgumentException($"Invalid field: {element.Name}.");
}
}
return(new TransactionOptions(readConcern, readPreference, writeConcern, maxCommitTimeMS));
}
private void AssertValid(ConnectionString connectionString, BsonDocument definition)
{
if (!definition["valid"].ToBoolean())
{
throw new AssertionException($"The connection string '{definition["uri"]}' should be invalid.");
}
BsonValue readConcernValue;
if (definition.TryGetValue("readConcern", out readConcernValue))
{
var readConcern = ReadConcern.FromBsonDocument((BsonDocument)readConcernValue);
connectionString.ReadConcernLevel.Should().Be(readConcern.Level);
}
BsonValue writeConcernValue;
if (definition.TryGetValue("writeConcern", out writeConcernValue))
{
var writeConcern = WriteConcern.FromBsonDocument(MassageWriteConcernDocument((BsonDocument)writeConcernValue));
connectionString.W.Should().Be(writeConcern.W);
connectionString.WTimeout.Should().Be(writeConcern.WTimeout);
connectionString.Journal.Should().Be(writeConcern.Journal);
connectionString.FSync.Should().Be(writeConcern.FSync);
}
}
private TransactionOptions ParseTransactionOptions(BsonDocument document)
{
ReadConcern readConcern = null;
ReadPreference readPreference = null;
WriteConcern writeConcern = null;
foreach (var element in document)
{
switch (element.Name)
{
case "readConcern":
readConcern = ReadConcern.FromBsonDocument(element.Value.AsBsonDocument);
break;
case "readPreference":
readPreference = ReadPreference.FromBsonDocument(element.Value.AsBsonDocument);
break;
case "writeConcern":
writeConcern = WriteConcern.FromBsonDocument(element.Value.AsBsonDocument);
break;
default:
throw new ArgumentException($"Invalid field: {element.Name}.");
}
}
return(new TransactionOptions(readConcern, readPreference, writeConcern));
}
// private methods
private TransactionOptions ParseTransactionOptions(BsonDocument document)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(document, "readConcern", "readPreference", "writeConcern", "maxCommitTimeMS");
var options = new TransactionOptions();
if (document.Contains("readConcern"))
{
options = options.With(readConcern: ReadConcern.FromBsonDocument(document["readConcern"].AsBsonDocument));
}
if (document.Contains("readPreference"))
{
options = options.With(readPreference: ReadPreference.FromBsonDocument(document["readPreference"].AsBsonDocument));
}
if (document.Contains("writeConcern"))
{
options = options.With(writeConcern: WriteConcern.FromBsonDocument(document["writeConcern"].AsBsonDocument));
}
if (document.Contains("maxCommitTimeMS"))
{
options = options.With(maxCommitTime: TimeSpan.FromMilliseconds(document["maxCommitTimeMS"].ToInt32()));
}
return(options);
}
protected override void SetArgument(string name, BsonValue value)
{
switch (name)
{
case "command":
_command = value.AsBsonDocument;
return;
case "databaseOptions":
if (value.AsBsonDocument.TryGetValue("readConcern", out var readConcernValue))
{
_readConcern = ReadConcern.FromBsonDocument(readConcernValue.AsBsonDocument);
}
return;
case "readPreference":
_readPreference = ReadPreference.FromBsonDocument(value.AsBsonDocument);
return;
case "session":
_session = (IClientSessionHandle)_objectMap[value.AsString];
return;
}
base.SetArgument(name, value);
}
private void ParseDatabaseOptions(BsonDocument document)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(document, "readConcern", "readPreference", "writeConcern");
var database = _collection.Database;
if (document.Contains("readConcern"))
{
var readConcern = ReadConcern.FromBsonDocument(document["readConcern"].AsBsonDocument);
database = database.WithReadConcern(readConcern);
}
if (document.Contains("readPreference"))
{
var readPreference = ReadPreference.FromBsonDocument(document["readPreference"].AsBsonDocument);
database = database.WithReadPreference(readPreference);
}
if (document.Contains("writeConcern"))
{
var writeConcern = WriteConcern.FromBsonDocument(document["writeConcern"].AsBsonDocument);
database = database.WithWriteConcern(writeConcern);
}
// update _collection to be associated with the reconfigured database
_collection = database.GetCollection <BsonDocument>(
_collection.CollectionNamespace.CollectionName,
_collection.Settings);
}
private IMongoCollection <BsonDocument> CreateCollection(BsonDocument entity, Dictionary <string, IMongoDatabase> databases)
{
string collectionName = null;
IMongoDatabase database = null;
MongoCollectionSettings settings = null;
foreach (var element in entity)
{
switch (element.Name)
{
case "id":
// handled on higher level
break;
case "database":
var databaseId = entity["database"].AsString;
database = databases[databaseId];
break;
case "collectionName":
collectionName = entity["collectionName"].AsString;
break;
case "collectionOptions":
settings = new MongoCollectionSettings();
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "readConcern":
settings.ReadConcern = ReadConcern.FromBsonDocument(option.Value.AsBsonDocument);
break;
case "readPreference":
settings.ReadPreference = ReadPreference.FromBsonDocument(option.Value.AsBsonDocument);
break;
case "writeConcern":
settings.WriteConcern = WriteConcern.FromBsonDocument(option.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Invalid collection option argument name: '{option.Name}'.");
}
}
break;
default:
throw new FormatException($"Invalid collection argument name: '{element.Name}'.");
}
}
return(database.GetCollection <BsonDocument>(collectionName, settings));
}
public void GetReadConcernForCommand_should_consider_session_supported_when_logicalSessionTimeoutMinutes_is_null_and_load_balanced_mode()
{
var session = CreateSession(
isInTransaction: false,
isCausallyConsistent: true,
operationTime: new BsonTimestamp(1234));
var connectionDescription = CreateConnectionDescription(logicalSessionTimeoutMinutes: false, serviceId: true);
var readConcern = ReadConcern.FromBsonDocument(BsonDocument.Parse("{}"));
var result = ReadConcernHelper.GetReadConcernForCommand(session, connectionDescription, readConcern);
result.Should().Be(new BsonDocument("afterClusterTime", new BsonTimestamp(1234)));
}
// private methods
private void SetOptions(BsonDocument document)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(document, "readConcern", "writeConcern");
if (document.Contains("readConcern"))
{
_options = _options.With(readConcern: ReadConcern.FromBsonDocument(document["readConcern"].AsBsonDocument));
}
if (document.Contains("writeConcern"))
{
_options = _options.With(writeConcern: WriteConcern.FromBsonDocument(document["writeConcern"].AsBsonDocument));
}
}
public void CreateCommand_should_return_expected_result_when_readConcern_is_provided(
[Values("{level: 'local'}", "{level: 'majority'}")]
string readConcernJson)
{
var subject = new FindCommandOperation <BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.ReadConcern = ReadConcern.FromBsonDocument(BsonDocument.Parse(readConcernJson));
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', readConcern : {readConcernJson} }}");
}
private void ParseCollectionOptions(MongoCollectionSettings settings, BsonDocument collectionOptions)
{
foreach (var collectionOption in collectionOptions.Elements)
{
switch (collectionOption.Name)
{
case "readConcern":
settings.ReadConcern = ReadConcern.FromBsonDocument(collectionOption.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Unexpected collection option: {collectionOption.Name}");
}
}
}
public void GetReadConcernForCommand_should_return_expected_result(
bool isInTransaction,
bool isCausallyConsistent,
int?operationTime,
string readConcernJson,
string expectedResult)
{
var session = CreateSession(
isInTransaction: isInTransaction,
isCausallyConsistent: isCausallyConsistent,
operationTime: operationTime.HasValue ? new BsonTimestamp(operationTime.Value) : null);
var connectionDescription = CreateConnectionDescription(areSessionsSupported: true);
var readConcern = ReadConcern.FromBsonDocument(BsonDocument.Parse(readConcernJson));
var result = ReadConcernHelper.GetReadConcernForCommand(session, connectionDescription, readConcern);
result.Should().Be(expectedResult);
}
public void GetReadConcernForFirstCommandInTransaction_should_return_expected_result(
bool isCausallyConsistent,
int?operationTime,
string readConcernJson,
string expectedResult)
{
var readConcern = ReadConcern.FromBsonDocument(BsonDocument.Parse(readConcernJson));
var transactionOptions = new TransactionOptions(readConcern);
var transaction = new CoreTransaction(1, transactionOptions);
var session = CreateSession(
currentTransaction: transaction,
isCausallyConsistent: isCausallyConsistent,
operationTime: operationTime.HasValue ? new BsonTimestamp(operationTime.Value) : null);
var connectionDescription = CreateConnectionDescription(logicalSessionTimeoutMinutes: true);
var result = ReadConcernHelper.GetReadConcernForFirstCommandInTransaction(session, connectionDescription);
result.Should().Be(expectedResult);
}
// private methods
private void ParseCollectionOptions(BsonDocument document)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(document, "readConcern", "readPreference", "writeConcern");
if (document.Contains("readConcern"))
{
var readConcern = ReadConcern.FromBsonDocument(document["readConcern"].AsBsonDocument);
_collection = _collection.WithReadConcern(readConcern);
}
if (document.Contains("readPreference"))
{
var readPreference = ReadPreference.FromBsonDocument(document["readPreference"].AsBsonDocument);
_collection = _collection.WithReadPreference(readPreference);
}
if (document.Contains("writeConcern"))
{
var writeConcern = WriteConcern.FromBsonDocument(document["writeConcern"].AsBsonDocument);
_collection = _collection.WithWriteConcern(writeConcern);
}
}
// private methods
private void SetOptions(BsonDocument document)
{
JsonDrivenHelper.EnsureAllFieldsAreValid(document, "readConcern", "readPreference", "writeConcern");
var options = new TransactionOptions();
if (document.Contains("readConcern"))
{
options = options.With(readConcern: ReadConcern.FromBsonDocument(document["readConcern"].AsBsonDocument));
}
if (document.Contains("readPreference"))
{
options = options.With(readPreference: ReadPreference.FromBsonDocument(document["readPreference"].AsBsonDocument));
}
if (document.Contains("writeConcern"))
{
options = options.With(writeConcern: WriteConcern.FromBsonDocument(document["writeConcern"].AsBsonDocument));
}
_options = options;
}
public UnifiedWithTransactionOperation Build(string targetSessionId, BsonDocument arguments)
{
var session = _entityMap.GetSession(targetSessionId);
BsonArray operations = null;
TransactionOptions options = null;
foreach (var argument in arguments)
{
switch (argument.Name)
{
case "callback":
operations = argument.Value.AsBsonArray;
break;
case "readConcern":
options = options ?? new TransactionOptions();
options = options.With(readConcern: ReadConcern.FromBsonDocument(argument.Value.AsBsonDocument));
break;
case "readPreference":
options = options ?? new TransactionOptions();
options = options.With(readPreference: ReadPreference.FromBsonDocument(argument.Value.AsBsonDocument));
break;
case "writeConcern":
options = options ?? new TransactionOptions();
options = options.With(writeConcern: WriteConcern.FromBsonDocument(argument.Value.AsBsonDocument));
break;
default:
throw new FormatException($"Invalid WithTransactionOperation argument name: '{argument.Name}'.");
}
}
return(new UnifiedWithTransactionOperation(session, operations, options));
}
private IClientSessionHandle CreateSession(BsonDocument entity, Dictionary <string, DisposableMongoClient> clients)
{
IMongoClient client = null;
ClientSessionOptions options = null;
foreach (var element in entity)
{
switch (element.Name)
{
case "id":
// handled on higher level
break;
case "client":
var clientId = element.Value.AsString;
client = clients[clientId];
break;
case "sessionOptions":
options = new ClientSessionOptions();
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "snapshot":
options.Snapshot = option.Value.ToBoolean();
break;
case "causalConsistency":
options.CausalConsistency = option.Value.ToBoolean();
break;
case "defaultTransactionOptions":
ReadConcern readConcern = null;
ReadPreference readPreference = null;
WriteConcern writeConcern = null;
foreach (var transactionOption in option.Value.AsBsonDocument)
{
switch (transactionOption.Name)
{
case "readConcern":
readConcern = ReadConcern.FromBsonDocument(transactionOption.Value.AsBsonDocument);
break;
case "readPreference":
readPreference = ReadPreference.FromBsonDocument(transactionOption.Value.AsBsonDocument);
break;
case "writeConcern":
writeConcern = WriteConcern.FromBsonDocument(transactionOption.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Invalid session transaction option: '{transactionOption.Name}'.");
}
}
options.DefaultTransactionOptions = new TransactionOptions(readConcern, readPreference, writeConcern);
break;
default:
throw new FormatException($"Invalid session option argument name: '{option.Name}'.");
}
}
break;
default:
throw new FormatException($"Invalid session argument name: '{element.Name}'.");
}
}
var session = client.StartSession(options);
return(session);
}
