/// <summary>
/// Throws if the read concern value is not the server default and read concern is not supported.
/// </summary>
/// <param name="serverVersion">The server version.</param>
/// <param name="value">The value.</param>
public void ThrowIfNotSupported(SemanticVersion serverVersion, ReadConcern value)
{
if (!value.IsServerDefault && !base.IsSupported(serverVersion))
{
throw new MongoClientException($"Server version {serverVersion} does not support read concern.");
}
}
public void ToBsonDocument_should_return_expected_result(ReadConcernLevel? level, string json)
{
var subject = new ReadConcern(level);
var result = subject.ToBsonDocument();
result.Should().Be(json);
}
public void Constructor_with_level_should_initialize_instance(
[Values(ReadConcernLevel.Local, ReadConcernLevel.Majority, null)]
ReadConcernLevel? level)
{
var result = new ReadConcern(level);
result.Level.Should().Be(level);
}
/// <summary>
/// Initializes a new instance of the <see cref="GridFSBucketOptions"/> class.
/// </summary>
/// <param name="other">The other <see cref="ImmutableGridFSBucketOptions"/> from which to copy the values.</param>
public GridFSBucketOptions(ImmutableGridFSBucketOptions other)
{
Ensure.IsNotNull(other, nameof(other));
_bucketName = other.BucketName;
_chunkSizeBytes = other.ChunkSizeBytes;
_readConcern = other.ReadConcern;
_readPreference = other.ReadPreference;
_writeConcern = other.WriteConcern;
}
public void CreateCommand_should_create_the_correct_command(
[Values("3.0.0", "3.2.0")] string serverVersionString,
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel? readConcernLevel)
{
var serverVersion = SemanticVersion.Parse(serverVersionString);
var filter = new BsonDocument("x", 1);
var limit = 10;
var maxDistance = 30;
var maxTime = TimeSpan.FromMilliseconds(50);
var near = new BsonArray { 10, 20 };
var readConcern = new ReadConcern(readConcernLevel);
var subject = new GeoSearchOperation<BsonDocument>(_collectionNamespace, near, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Search = filter,
Limit = limit,
MaxDistance = maxDistance,
MaxTime = maxTime,
ReadConcern = readConcern
};
if (!readConcern.IsServerDefault && !Feature.ReadConcern.IsSupported(serverVersion))
{
var exception = Record.Exception(() => subject.CreateCommand(serverVersion));
exception.Should().BeOfType<MongoClientException>();
}
else
{
var result = subject.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "geoSearch", _collectionNamespace.CollectionName },
{ "near", near },
{ "limit", limit },
{ "maxDistance", maxDistance },
{ "search", filter },
{ "maxTimeMS", maxTime.TotalMilliseconds },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
}
public IMongoCollection <TDocument> WithReadConcern(ReadConcern readConcern)
{
throw new NotImplementedException();
}
private void CreateClient(BsonDocument entity, out DisposableMongoClient client, out EventCapturer eventCapturer)
{
var eventTypesToCapture = new List <string>();
var commandNamesToSkip = new List <string>
{
"authenticate",
"buildInfo",
"configureFailPoint",
"getLastError",
"getnonce",
"isMaster",
"saslContinue",
"saslStart"
};
var readConcern = ReadConcern.Default;
var retryReads = true;
var retryWrites = true;
var useMultipleShardRouters = false;
var writeConcern = WriteConcern.Acknowledged;
foreach (var element in entity)
{
switch (element.Name)
{
case "id":
// handled on higher level
break;
case "useMultipleMongoses":
useMultipleShardRouters = element.Value.AsBoolean;
break;
case "observeEvents":
eventTypesToCapture.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
break;
case "ignoreCommandMonitoringEvents":
commandNamesToSkip.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
break;
case "uriOptions":
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "retryWrites":
retryWrites = option.Value.AsBoolean;
break;
case "retryReads":
retryReads = option.Value.AsBoolean;
break;
case "readConcernLevel":
var levelValue = option.Value.AsString;
var level = (ReadConcernLevel)Enum.Parse(typeof(ReadConcernLevel), levelValue, true);
readConcern = new ReadConcern(level);
break;
case "w":
writeConcern = new WriteConcern(option.Value.AsInt32);
break;
default:
throw new FormatException($"Unrecognized client uriOption name: '{option.Name}'.");
}
}
break;
default:
throw new FormatException($"Unrecognized client entity field: '{element.Name}'.");
}
}
eventCapturer = null;
if (eventTypesToCapture.Count > 0)
{
eventCapturer = new EventCapturer();
foreach (var eventTypeToCapture in eventTypesToCapture)
{
switch (eventTypeToCapture)
{
case "commandStartedEvent":
eventCapturer = eventCapturer.Capture <CommandStartedEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
break;
case "commandSucceededEvent":
eventCapturer = eventCapturer.Capture <CommandSucceededEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
break;
case "commandFailedEvent":
eventCapturer = eventCapturer.Capture <CommandFailedEvent>(x => !commandNamesToSkip.Contains(x.CommandName));
break;
default:
throw new FormatException($"Invalid event name: {eventTypeToCapture}.");
}
}
}
var localEventCapturer = eventCapturer; // copy value of eventCapturer ref variable to a local variable (to avoid error CS1628)
client = DriverTestConfiguration.CreateDisposableClient(
settings =>
{
settings.RetryReads = retryReads;
settings.RetryWrites = retryWrites;
settings.ReadConcern = readConcern;
settings.WriteConcern = writeConcern;
settings.HeartbeatInterval = TimeSpan.FromMilliseconds(5); // the default value for spec tests
if (localEventCapturer != null)
{
settings.ClusterConfigurator = c => c.Subscribe(localEventCapturer);
}
},
useMultipleShardRouters);
}
public void TestWithReadConcern()
{
var originalReadConcern = new ReadConcern(ReadConcernLevel.Linearizable);
var subject = __server.WithReadConcern(originalReadConcern);
var newReadConcern = new ReadConcern(ReadConcernLevel.Majority);
var result = subject.WithReadConcern(newReadConcern);
subject.Settings.ReadConcern.Should().BeSameAs(originalReadConcern);
result.Settings.ReadConcern.Should().BeSameAs(newReadConcern);
result.WithReadConcern(originalReadConcern).Settings.Should().Be(subject.Settings);
}
public abstract IMongoDatabase WithReadConcern(ReadConcern readConcern);
public void Execute_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Local)]
ReadConcernLevel? level,
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Aggregate, Feature.ReadConcern);
EnsureTestData();
var readConcern = new ReadConcern(level);
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var cursor = ExecuteOperation(subject, async);
var result = ReadCursorToEnd(cursor, async);
result.Should().NotBeNull();
result.Should().HaveCount(1);
}
public FileDocumentTypeBuilder <T> WithReadConcern(ReadConcern readConcern)
{
ReadConcern = readConcern;
_apply(this);
return(this);
}
public void CreateCommand_should_include_read_concern_when_appropriate(
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel? readConcernLevel)
{
var readConcern = new ReadConcern(readConcernLevel);
var mapFunction = "function() { emit(this.x, this.v); }";
var reduceFunction = "function(key, values) { var sum = 0; for (var i = 0; i < values.length; i++) { sum += values[i]; }; return sum; }";
var subject = new MapReduceLegacyOperation(_collectionNamespace, mapFunction, reduceFunction, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var command = subject.CreateCommand(new SemanticVersion(3, 2, 0));
if (readConcern.IsServerDefault)
{
command.Contains("readConcern").Should().BeFalse();
}
else
{
command["readConcern"].Should().Be(readConcern.ToBsonDocument());
}
}
public IMongoClient WithReadConcern(ReadConcern readConcern)
{
return(this);
}
private (DisposableMongoClient Client, Dictionary <string, EventCapturer> ClientEventCapturers) CreateClient(BsonDocument entity)
{
string appName = null;
var clientEventCapturers = new Dictionary <string, EventCapturer>();
string clientId = null;
var commandNamesToSkipInEvents = new List <string>();
List <(string Key, IEnumerable <string> Events, List <string> CommandNotToCapture)> eventTypesToCapture = new ();
bool? loadBalanced = null;
int? maxPoolSize = null;
bool? observeSensitiveCommands = null;
var readConcern = ReadConcern.Default;
var retryReads = true;
var retryWrites = true;
var useMultipleShardRouters = false;
TimeSpan?waitQueueTimeout = null;
var writeConcern = WriteConcern.Acknowledged;
var serverApi = CoreTestConfiguration.ServerApi;
foreach (var element in entity)
{
switch (element.Name)
{
case "id":
clientId = element.Value.AsString;
break;
case "uriOptions":
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "appname":
appName = option.Value.ToString();
break;
case "loadBalanced":
loadBalanced = option.Value.ToBoolean();
break;
case "maxPoolSize":
maxPoolSize = option.Value.ToInt32();
break;
case "retryWrites":
retryWrites = option.Value.AsBoolean;
break;
case "retryReads":
retryReads = option.Value.AsBoolean;
break;
case "readConcernLevel":
var levelValue = option.Value.AsString;
var level = (ReadConcernLevel)Enum.Parse(typeof(ReadConcernLevel), levelValue, true);
readConcern = new ReadConcern(level);
break;
case "w":
writeConcern = new WriteConcern(option.Value.AsInt32);
break;
case "waitQueueTimeoutMS":
waitQueueTimeout = TimeSpan.FromMilliseconds(option.Value.ToInt32());
break;
default:
throw new FormatException($"Invalid client uriOption argument name: '{option.Name}'.");
}
}
break;
case "useMultipleMongoses":
useMultipleShardRouters = element.Value.AsBoolean;
RequireServer.Check().MultipleMongosesIfSharded(required: useMultipleShardRouters);
break;
case "observeEvents":
var observeEvents = element.Value.AsBsonArray.Select(x => x.AsString);
eventTypesToCapture.Add(
(Key: Ensure.IsNotNull(clientId, nameof(clientId)),
Events: observeEvents,
CommandNotToCapture: commandNamesToSkipInEvents));
break;
case "observeSensitiveCommands":
observeSensitiveCommands = element.Value.AsBoolean;
break;
case "ignoreCommandMonitoringEvents":
commandNamesToSkipInEvents.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
break;
case "serverApi":
ServerApiVersion serverApiVersion = null;
bool? serverApiStrict = null;
bool? serverApiDeprecationErrors = null;
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "version":
var serverApiVersionString = option.Value.AsString;
switch (serverApiVersionString)
{
case "1":
serverApiVersion = ServerApiVersion.V1;
break;
default:
throw new FormatException($"Invalid serverApi version: '{serverApiVersionString}'.");
}
break;
case "strict":
serverApiStrict = option.Value.AsBoolean;
break;
case "deprecationErrors":
serverApiDeprecationErrors = option.Value.AsBoolean;
break;
default:
throw new FormatException($"Invalid client serverApi argument name: '{option.Name}'.");
}
}
if (serverApiVersion != null)
{
serverApi = new ServerApi(serverApiVersion, serverApiStrict, serverApiDeprecationErrors);
}
break;
case "storeEventsAsEntities":
var eventsBatches = element.Value.AsBsonArray;
foreach (var batch in eventsBatches.Cast <BsonDocument>())
{
var id = batch["id"].AsString;
var events = batch["events"].AsBsonArray.Select(e => e.AsString);
eventTypesToCapture.Add((id, events, CommandNotToCapture: null));
}
break;
default:
throw new FormatException($"Invalid client argument name: '{element.Name}'.");
}
}
// Regardless of whether events are observed, we still need to track some info about the pool in order to implement
// the assertNumberConnectionsCheckedOut operation
if (eventTypesToCapture.Count == 0)
{
eventTypesToCapture.Add(
(Key: Ensure.IsNotNull(clientId, nameof(clientId)),
Events: new[] { "connectionCheckedInEvent", "connectionCheckedOutEvent" },
CommandNotToCapture: commandNamesToSkipInEvents));
}
var defaultCommandNamesToSkip = new List <string>
{
"buildInfo",
"configureFailPoint",
"getLastError",
OppressiveLanguageConstants.LegacyHelloCommandName, // skip handshake events, should be reconsidered in the scope of CSHARP-3823
"hello"
};
if (!observeSensitiveCommands.GetValueOrDefault())
{
defaultCommandNamesToSkip.AddRange(new[]
{
"authenticate",
"getnonce",
"saslContinue",
"saslStart"
});
}
foreach (var eventsDetails in eventTypesToCapture)
{
var commandNamesNotToCapture = Enumerable.Concat(eventsDetails.CommandNotToCapture ?? Enumerable.Empty <string>(), defaultCommandNamesToSkip);
var formatter = _eventFormatters.ContainsKey(eventsDetails.Key) ? _eventFormatters[eventsDetails.Key] : null;
var eventCapturer = CreateEventCapturer(eventsDetails.Events, commandNamesNotToCapture, formatter);
clientEventCapturers.Add(eventsDetails.Key, eventCapturer);
}
var eventCapturers = clientEventCapturers.Select(c => c.Value).ToArray();
var client = DriverTestConfiguration.CreateDisposableClient(
settings =>
{
settings.ApplicationName = appName;
settings.LoadBalanced = loadBalanced.GetValueOrDefault(defaultValue: settings.LoadBalanced);
settings.MaxConnectionPoolSize = maxPoolSize.GetValueOrDefault(defaultValue: settings.MaxConnectionPoolSize);
settings.RetryReads = retryReads;
settings.RetryWrites = retryWrites;
settings.ReadConcern = readConcern;
settings.WaitQueueTimeout = waitQueueTimeout.GetValueOrDefault(defaultValue: settings.WaitQueueTimeout);
settings.WriteConcern = writeConcern;
settings.HeartbeatInterval = TimeSpan.FromMilliseconds(5); // the default value for spec tests
settings.ServerApi = serverApi;
if (eventCapturers.Length > 0)
{
settings.ClusterConfigurator = c =>
{
foreach (var eventCapturer in eventCapturers)
{
c.Subscribe(eventCapturer);
}
};
}
},
_loggerFactory.CreateLogger <DisposableMongoClient>(),
useMultipleShardRouters);
return(client, clientEventCapturers);
}
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 "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($"Unrecognized session option: '{option.Name}'.");
}
}
break;
default:
throw new FormatException($"Unrecognized database entity field: '{element.Name}'.");
}
}
var session = client.StartSession(options);
return(session);
}
private (DisposableMongoClient Client, Dictionary <string, EventCapturer> ClientEventCapturers) CreateClient(BsonDocument entity)
{
var clientEventCapturers = new Dictionary <string, EventCapturer>();
string clientId = null;
var commandNamesToSkipInEvents = new List <string>();
List <(string Key, IEnumerable <string> Events, List <string> CommandNotToCapture)> eventTypesToCapture = new ();
var readConcern = ReadConcern.Default;
var retryReads = true;
var retryWrites = true;
var useMultipleShardRouters = false;
var writeConcern = WriteConcern.Acknowledged;
ServerApi serverApi = null;
foreach (var element in entity)
{
switch (element.Name)
{
case "id":
clientId = element.Value.AsString;
break;
case "uriOptions":
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "retryWrites":
retryWrites = option.Value.AsBoolean;
break;
case "retryReads":
retryReads = option.Value.AsBoolean;
break;
case "readConcernLevel":
var levelValue = option.Value.AsString;
var level = (ReadConcernLevel)Enum.Parse(typeof(ReadConcernLevel), levelValue, true);
readConcern = new ReadConcern(level);
break;
case "w":
writeConcern = new WriteConcern(option.Value.AsInt32);
break;
default:
throw new FormatException($"Unrecognized client uriOption name: '{option.Name}'.");
}
}
break;
case "useMultipleMongoses":
useMultipleShardRouters = element.Value.AsBoolean;
break;
case "observeEvents":
var observeEvents = element.Value.AsBsonArray.Select(x => x.AsString);
eventTypesToCapture.Add(
(Key: Ensure.IsNotNull(clientId, nameof(clientId)),
Events: observeEvents,
CommandNotToCapture: commandNamesToSkipInEvents));
break;
case "ignoreCommandMonitoringEvents":
commandNamesToSkipInEvents.AddRange(element.Value.AsBsonArray.Select(x => x.AsString));
break;
case "serverApi":
ServerApiVersion serverApiVersion = null;
bool? serverApiStrict = null;
bool? serverApiDeprecationErrors = null;
foreach (var option in element.Value.AsBsonDocument)
{
switch (option.Name)
{
case "version":
var serverApiVersionString = option.Value.AsString;
switch (serverApiVersionString)
{
case "1":
serverApiVersion = ServerApiVersion.V1;
break;
default:
throw new FormatException($"Unrecognized serverApi version: '{serverApiVersionString}'.");
}
break;
case "strict":
serverApiStrict = option.Value.AsBoolean;
break;
case "deprecationErrors":
serverApiDeprecationErrors = option.Value.AsBoolean;
break;
default:
throw new FormatException($"Unrecognized client serverApi option name: '{option.Name}'.");
}
}
if (serverApiVersion != null)
{
serverApi = new ServerApi(serverApiVersion, serverApiStrict, serverApiDeprecationErrors);
}
break;
case "storeEventsAsEntities":
var eventsBatches = element.Value.AsBsonArray;
foreach (var batch in eventsBatches.Cast <BsonDocument>())
{
var id = batch["id"].AsString;
var events = batch["events"].AsBsonArray.Select(e => e.AsString);
eventTypesToCapture.Add((id, events, CommandNotToCapture: null));
}
break;
default:
throw new FormatException($"Unrecognized client entity field: '{element.Name}'.");
}
}
if (eventTypesToCapture.Count > 0)
{
var defaultCommandNamesToSkip = new List <string>
{
"authenticate",
"buildInfo",
"configureFailPoint",
"getLastError",
"getnonce",
"isMaster",
"saslContinue",
"saslStart"
};
foreach (var eventsDetails in eventTypesToCapture)
{
var commandNamesNotToCapture = Enumerable.Concat(eventsDetails.CommandNotToCapture ?? Enumerable.Empty <string>(), defaultCommandNamesToSkip);
var formatter = _eventFormatters.ContainsKey(eventsDetails.Key) ? _eventFormatters[eventsDetails.Key] : null;
var eventCapturer = CreateEventCapturer(eventsDetails.Events, commandNamesNotToCapture, formatter);
clientEventCapturers.Add(eventsDetails.Key, eventCapturer);
}
}
var eventCapturers = clientEventCapturers.Select(c => c.Value).ToArray();
var client = DriverTestConfiguration.CreateDisposableClient(
settings =>
{
settings.RetryReads = retryReads;
settings.RetryWrites = retryWrites;
settings.ReadConcern = readConcern;
settings.WriteConcern = writeConcern;
settings.HeartbeatInterval = TimeSpan.FromMilliseconds(5); // the default value for spec tests
settings.ServerApi = serverApi;
if (eventCapturers.Length > 0)
{
settings.ClusterConfigurator = c =>
{
foreach (var eventCapturer in eventCapturers)
{
c.Subscribe(eventCapturer);
}
};
}
},
useMultipleShardRouters);
return(client, clientEventCapturers);
}
public virtual IMongoCollection <TVal> WithReadConcern(ReadConcern readConcern) => throw new NotImplementedException();
public IMongoClient WithReadConcern(ReadConcern readConcern)
{
return(_client.WithReadConcern(readConcern));
}
public void WithReadConcern_should_return_expected_result()
{
var originalReadConcern = new ReadConcern(ReadConcernLevel.Linearizable);
var subject = new MongoClient().WithReadConcern(originalReadConcern);
var newReadConcern = new ReadConcern(ReadConcernLevel.Majority);
var result = subject.WithReadConcern(newReadConcern);
subject.Settings.ReadConcern.Should().BeSameAs(originalReadConcern);
result.Settings.ReadConcern.Should().BeSameAs(newReadConcern);
result.WithReadConcern(originalReadConcern).Settings.Should().Be(subject.Settings);
}
public override IMongoDatabase WithReadConcern(ReadConcern readConcern)
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public IMongoDatabase WithReadConcern(ReadConcern readConcern)
{
return(_configuration.Database.WithReadConcern(readConcern));
}
public void With_should_return_same_instance_when_all_values_are_equal()
{
var subject = new ReadConcern(ReadConcernLevel.Local);
var result = subject.With(ReadConcernLevel.Local);
result.Should().BeSameAs(subject);
}
public IMongoClient WithReadConcern(ReadConcern readConcern)
{
throw new NotImplementedException();
}
public IMongoCollection <AnimatedImage> WithReadConcern(ReadConcern readConcern)
{
throw new NotImplementedException();
}
public IMongoDatabase WithReadConcern(ReadConcern readConcern)
{
return(_database.WithReadConcern(readConcern));
}
public void Execute_should_throw_when_ReadConcern_is_set_but_not_supported(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Aggregate).DoesNotSupport(Feature.ReadConcern);
var readConcern = new ReadConcern(ReadConcernLevel.Linearizable);
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<MongoClientException>();
}
public SessionBehaviorBuilder <T> WithReadConcern(ReadConcern readConcern)
{
ReadConcern = readConcern;
_apply(this);
return(this);
}
public void ReadConcern_get_and_set_should_work(
[Values(ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel level)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = new ReadConcern(level);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().Be(value);
}
public IMongoClient WithReadConcern(ReadConcern readConcern)
{
return(((IMongoClient)Client).WithReadConcern(readConcern));
}
public IMongoClient WithReadConcern(ReadConcern readConcern) => _mongoClient.WithReadConcern(readConcern);
/// <inheritdoc />
public virtual IMongoClient WithReadConcern(ReadConcern readConcern)
{
throw new NotImplementedException();
}
// private static methods
private static BsonDocument ToBsonDocument(ICoreSession session, ConnectionDescription connectionDescription, ReadConcern readConcern)
{
// causal consistency
var shouldSendAfterClusterTime = AreSessionsSupported(connectionDescription) && session.IsCausallyConsistent && session.OperationTime != null;
var shouldSendReadConcern = !readConcern.IsServerDefault || shouldSendAfterClusterTime;
if (shouldSendReadConcern)
{
var readConcernDocument = readConcern.ToBsonDocument();
if (shouldSendAfterClusterTime)
{
readConcernDocument.Add("afterClusterTime", session.OperationTime);
}
return(readConcernDocument);
}
return(null);
}
public virtual IMongoClient WithReadConcern(ReadConcern readConcern) => throw new NotImplementedException();
/// <inheritdoc/>
public IMongoCollection <T> WithReadConcern(ReadConcern readConcern)
{
throw new System.NotImplementedException();
}
/// <inheritdoc/>
public IMongoCollection <T> WithReadConcern(ReadConcern readConcern)
{
return(_actualCollection.WithReadConcern(readConcern));
}
public abstract IMongoCollection <TDocument> WithReadConcern(ReadConcern readConcern);
public abstract IMongoClient WithReadConcern(ReadConcern readConcern);
public IMongoCollection <TModel> WithReadConcern(ReadConcern readConcern)
{
return(_collection.WithReadConcern(readConcern));
}
public IMongoCollection <TModel> WithReadConcern(ReadConcern readConcern) => _collection.WithReadConcern(readConcern);
public IMongoClient WithReadConcern(ReadConcern readConcern)
{
return(wrapped.WithReadConcern(readConcern));
}
/// <inheritdoc/>
public IMongoDatabase WithReadConcern(ReadConcern readConcern)
{
throw new System.NotImplementedException();
}
public static BsonDocument GetReadConcernForCommand(ICoreSession session, ConnectionDescription connectionDescription, ReadConcern readConcern)
{
return(session.IsInTransaction ? null : ToBsonDocument(session, connectionDescription, readConcern));
}
public IMongoCollection <T> WithReadConcern(ReadConcern readConcern) => _base.WithReadConcern(readConcern);
public void With_should_return_new_instance_when_level_is_not_the_same()
{
var subject = new ReadConcern(null);
var result = subject.With(ReadConcernLevel.Majority);
result.Should().NotBeSameAs(subject);
result.Level.Should().Be(ReadConcernLevel.Majority);
}
public void ReadConcern_get_and_set_should_work()
{
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings);
var value = new ReadConcern(ReadConcernLevel.Linearizable);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().BeSameAs(value);
}
public void With_should_return_same_instance_when_no_values_are_provided()
{
var subject = new ReadConcern();
var result = subject.With();
result.Should().BeSameAs(subject);
}
public void CreateCommand_should_return_the_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable)]
ReadConcernLevel? level)
{
var readConcern = new ReadConcern(level);
var subject = new AggregateOperation<BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = subject.CreateCommand(Feature.ReadConcern.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "readConcern", () => readConcern.ToBsonDocument(), level != null },
{ "cursor", new BsonDocument() }
};
result.Should().Be(expectedResult);
}
/// <inheritdoc/>
public override IMongoClient WithReadConcern(ReadConcern readConcern)
{
Ensure.IsNotNull(readConcern, nameof(readConcern));
var newSettings = Settings.Clone();
newSettings.ReadConcern = readConcern;
return new MongoClient(_operationExecutor, newSettings);
}
public void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel? level)
{
var readConcern = new ReadConcern(level);
var subject = new GeoNearOperation<BsonDocument>(_collectionNamespace, _near, _resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = subject.CreateCommand(Feature.ReadConcern.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "geoNear", _collectionNamespace.CollectionName },
{ "near", new BsonArray { 1, 2 } },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
