public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level.HasValue ? new ReadConcern(level.Value) : ReadConcern.Default;
var subject = new DistinctOperation <int>(_collectionNamespace, _valueSerializer, _fieldName, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(supportsSessions: true);
var session = OperationTestHelper.CreateSession(true, new BsonTimestamp(100));
var result = subject.CreateCommand(connectionDescription, session);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
var expectedResult = new BsonDocument
{
{ "distinct", _collectionNamespace.CollectionName },
{ "key", _fieldName },
{ "readConcern", expectedReadConcernDocument }
};
result.Should().Be(expectedResult);
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationMechanismProperties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_authenticationSource = null;
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readConcernLevel = null;
_readPreference = null;
_replicaSetName = null;
_localThreshold = MongoDefaults.LocalThreshold;
_servers = new[] { new MongoServerAddress("localhost", 27017) };
_serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
_socketTimeout = MongoDefaults.SocketTimeout;
_username = null;
_useSsl = false;
_verifySslCertificate = true;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
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 connectionDescription = OperationTestHelper.CreateConnectionDescription();
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(connectionDescription, session);
var expectedResult = new BsonDocument
{
{ "geoNear", _collectionNamespace.CollectionName },
{ "near", new BsonArray {
1, 2
} },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new CountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(Feature.ReadConcern.FirstSupportedVersion, supportsSessions: true);
var session = OperationTestHelper.CreateSession(true, new BsonTimestamp(100));
var result = subject.CreateCommand(connectionDescription, session);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
var expectedResult = new BsonDocument
{
{ "count", _collectionNamespace.CollectionName },
{ "readConcern", expectedReadConcernDocument }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level.HasValue ? new ReadConcern(level.Value) : ReadConcern.Default;
var subject = new MapReduceOperation <BsonDocument>(_collectionNamespace, _mapFunction, _reduceFunction, _resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var session = OperationTestHelper.CreateSession(isCausallyConsistent: true, operationTime: new BsonTimestamp(100));
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion: Feature.ReadConcern.FirstSupportedVersion, supportsSessions: true);
var result = subject.CreateCommand(session, connectionDescription);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
var expectedResult = new BsonDocument
{
{ "mapReduce", _collectionNamespace.CollectionName },
{ "map", _mapFunction },
{ "reduce", _reduceFunction },
{ "out", new BsonDocument("inline", 1) },
{ "readConcern", expectedReadConcernDocument }
};
result.Should().Be(expectedResult);
}
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 CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level.HasValue ? new ReadConcern(level.Value) : ReadConcern.Default;
var subject = new MapReduceOperation <BsonDocument>(_collectionNamespace, _mapFunction, _reduceFunction, _resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion: Feature.ReadConcern.FirstSupportedVersion);
var result = subject.CreateCommand(session, connectionDescription);
var expectedResult = new BsonDocument
{
{ "mapreduce", _collectionNamespace.CollectionName },
{ "map", _mapFunction },
{ "reduce", _reduceFunction },
{ "out", new BsonDocument("inline", 1) },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
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 connectionDescription = OperationTestHelper.CreateConnectionDescription(Feature.ReadConcern.FirstSupportedVersion);
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(connectionDescription, session);
if (readConcern.IsServerDefault)
{
result.Contains("readConcern").Should().BeFalse();
}
else
{
result["readConcern"].Should().Be(readConcern.ToBsonDocument());
}
}
public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable)]
ReadConcernLevel?level)
{
var readConcern = new ReadConcern(level);
var subject = new AggregateOperation <BsonDocument>(_collectionNamespace, __pipeline, __resultSerializer, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(Feature.ReadConcern.FirstSupportedVersion, supportsSessions: true);
var session = OperationTestHelper.CreateSession(true, new BsonTimestamp(100));
var result = subject.CreateCommand(connectionDescription, session);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "readConcern", expectedReadConcernDocument },
{ "cursor", new BsonDocument() }
};
result.Should().Be(expectedResult);
}
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 connectionDescription = OperationTestHelper.CreateConnectionDescription(Feature.ReadConcern.FirstSupportedVersion);
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(connectionDescription, session);
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(__pipeline) },
{ "readConcern", () => readConcern.ToBsonDocument(), level != null },
{ "cursor", new BsonDocument() }
};
result.Should().Be(expectedResult);
}
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);
}
public void CreateCommand_should_create_the_correct_command(
[Values("3.0.0", "3.2.0")] string serverVersion,
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel?readConcernLevel)
{
var semanticServerVersion = SemanticVersion.Parse(serverVersion);
var distanceMultiplier = 40;
var filter = new BsonDocument("x", 1);
var includeLocs = true;
var limit = 10;
var maxDistance = 30;
var maxTime = TimeSpan.FromMilliseconds(50);
var near = new BsonArray {
10, 20
};
var spherical = true;
var uniqueDocs = true;
var subject = new GeoNearOperation <BsonDocument>(_collectionNamespace, near, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
DistanceMultiplier = distanceMultiplier,
Filter = filter,
IncludeLocs = includeLocs,
Limit = limit,
MaxDistance = maxDistance,
MaxTime = maxTime,
ReadConcern = new ReadConcern(readConcernLevel),
Spherical = spherical,
UniqueDocs = uniqueDocs
};
var expectedResult = new BsonDocument
{
{ "geoNear", _collectionNamespace.CollectionName },
{ "near", near },
{ "limit", limit },
{ "maxDistance", maxDistance },
{ "query", filter },
{ "spherical", spherical },
{ "distanceMultiplier", distanceMultiplier },
{ "includeLocs", includeLocs },
{ "uniqueDocs", uniqueDocs },
{ "maxTimeMS", maxTime.TotalMilliseconds }
};
if (!subject.ReadConcern.IsServerDefault)
{
expectedResult["readConcern"] = subject.ReadConcern.ToBsonDocument();
}
if (!subject.ReadConcern.IsSupported(semanticServerVersion))
{
Action act = () => subject.CreateCommand(semanticServerVersion);
act.ShouldThrow <MongoClientException>();
}
else
{
var result = subject.CreateCommand(semanticServerVersion);
result.Should().Be(expectedResult);
}
}
public void ReadConcern_get_and_set_should_work(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var value = level == null ? ReadConcern.Default : new ReadConcern(level.Value);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().BeSameAs(value);
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_allowInsecureTls = false;
_applicationName = null;
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationMechanismProperties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_authenticationSource = null;
_compressors = new CompressorConfiguration[0];
_connectionMode = ConnectionMode.Automatic;
#pragma warning disable CS0618 // Type or member is obsolete
_connectionModeSwitch = ConnectionModeSwitch.NotSet;
#pragma warning restore CS0618 // Type or member is obsolete
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_directConnection = null;
_fsync = null;
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
_guidRepresentation = MongoDefaults.GuidRepresentation;
}
#pragma warning restore 618
_heartbeatInterval = ServerSettings.DefaultHeartbeatInterval;
_heartbeatTimeout = ServerSettings.DefaultHeartbeatTimeout;
_ipv6 = false;
_journal = null;
_loadBalanced = false;
_localThreshold = MongoDefaults.LocalThreshold;
_maxConnecting = MongoInternalDefaults.ConnectionPool.MaxConnecting;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readConcernLevel = null;
_readPreference = null;
_replicaSetName = null;
_retryReads = null;
_retryWrites = null;
_scheme = ConnectionStringScheme.MongoDB;
_servers = new[] { new MongoServerAddress("localhost", 27017) };
_serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
_socketTimeout = MongoDefaults.SocketTimeout;
_srvMaxHosts = null;
_username = null;
_useTls = false;
_w = null;
#pragma warning disable 618
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
#pragma warning restore 618
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(string url)
{
_originalUrl = url;
var builder = new MongoUrlBuilder(url); // parses url
_allowInsecureTls = builder.AllowInsecureTls;
_applicationName = builder.ApplicationName;
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationMechanismProperties = builder.AuthenticationMechanismProperties;
_authenticationSource = builder.AuthenticationSource;
_compressors = builder.Compressors;
_connectionMode = builder.ConnectionMode;
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
_fsync = builder.FSync;
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
_guidRepresentation = builder.GuidRepresentation;
}
#pragma warning restore 618
_heartbeatInterval = builder.HeartbeatInterval;
_heartbeatTimeout = builder.HeartbeatTimeout;
_ipv6 = builder.IPv6;
_isResolved = builder.Scheme != ConnectionStringScheme.MongoDBPlusSrv;
_journal = builder.Journal;
_localThreshold = builder.LocalThreshold;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readConcernLevel = builder.ReadConcernLevel;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_retryReads = builder.RetryReads;
_retryWrites = builder.RetryWrites;
_scheme = builder.Scheme;
_servers = builder.Servers;
_serverSelectionTimeout = builder.ServerSelectionTimeout;
_socketTimeout = builder.SocketTimeout;
_tlsDisableCertificateRevocationCheck = builder.TlsDisableCertificateRevocationCheck;
_username = builder.Username;
_useTls = builder.UseTls;
_w = builder.W;
#pragma warning disable 618
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
#pragma warning restore 618
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
public void ReadConcern_get_and_set_should_work(
[Values(ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel?level)
{
var subject = CreateSubject();
var value = new ReadConcern(level);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().Be(value);
}
public void ReadConcern_get_and_set_should_work(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var subject = new FindOperation <BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = level.HasValue ? new ReadConcern(level.Value) : ReadConcern.Default;
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().Be(value);
}
public void ReadConcern_get_and_set_should_work(
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var subject = new DistinctOperation <int>(_collectionNamespace, _valueSerializer, _fieldName, _messageEncoderSettings);
var value = level.HasValue ? new ReadConcern(level) : ReadConcern.Default;
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().BeSameAs(value);
}
public void CreateCommand_should_create_the_correct_command(
[Values("2.4.0", "2.6.0", "2.8.0", "3.0.0", "3.2.0")] string serverVersion,
[Values(null, false, true)] bool?allowDiskUse,
[Values(null, 10, 20)] int?batchSize,
[Values(null, 2000)] int?maxTime,
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel?readConcernLevel,
[Values(null, false, true)] bool?useCursor)
{
var semanticServerVersion = SemanticVersion.Parse(serverVersion);
var subject = new AggregateOperation <BsonDocument>(_collectionNamespace, Enumerable.Empty <BsonDocument>(), BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
AllowDiskUse = allowDiskUse,
BatchSize = batchSize,
MaxTime = maxTime.HasValue ? TimeSpan.FromMilliseconds(maxTime.Value) : (TimeSpan?)null,
ReadConcern = new ReadConcern(readConcernLevel),
UseCursor = useCursor
};
var expectedResult = new BsonDocument
{
{ "aggregate", _collectionNamespace.CollectionName },
{ "pipeline", new BsonArray(subject.Pipeline) },
{ "allowDiskUse", () => allowDiskUse.Value, allowDiskUse.HasValue },
{ "maxTimeMS", () => maxTime.Value, maxTime.HasValue }
};
if (!subject.ReadConcern.IsServerDefault)
{
expectedResult["readConcern"] = subject.ReadConcern.ToBsonDocument();
}
if (SupportedFeatures.IsAggregateCursorResultSupported(semanticServerVersion) && useCursor.GetValueOrDefault(true))
{
expectedResult["cursor"] = new BsonDocument
{
{ "batchSize", () => batchSize.Value, batchSize.HasValue }
};
}
if (!subject.ReadConcern.IsSupported(semanticServerVersion))
{
Action act = () => subject.CreateCommand(semanticServerVersion);
act.ShouldThrow <MongoClientException>();
}
else
{
var result = subject.CreateCommand(semanticServerVersion);
result.Should().Be(expectedResult);
}
}
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
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion);
var session = OperationTestHelper.CreateSession();
if (!readConcern.IsServerDefault && !Feature.ReadConcern.IsSupported(serverVersion))
{
var exception = Record.Exception(() => subject.CreateCommand(connectionDescription, session));
exception.Should().BeOfType <MongoClientException>();
}
else
{
var result = subject.CreateCommand(connectionDescription, session);
var expectedResult = new BsonDocument
{
{ "geoSearch", _collectionNamespace.CollectionName },
{ "near", near },
{ "limit", limit },
{ "maxDistance", maxDistance },
{ "search", filter },
{ "maxTimeMS", (int)maxTime.TotalMilliseconds },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
result["maxTimeMS"].BsonType.Should().Be(BsonType.Int32);
}
}
public void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var session = OperationTestHelper.CreateSession();
var result = CreateCommand(subject, connectionDescription, session);
AssertCommandDocument(result, readConcern: readConcern.IsServerDefault?null: readConcern.ToBsonDocument());
}
public void Execute_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Local)] ReadConcernLevel?level,
[Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level.Value);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = ExecuteOperation(subject, async);
result.Should().Be(2);
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(string url)
{
_originalUrl = url;
var builder = new MongoUrlBuilder(url); // parses url
_applicationName = builder.ApplicationName;
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationMechanismProperties = builder.AuthenticationMechanismProperties;
_authenticationSource = builder.AuthenticationSource;
_connectionMode = builder.ConnectionMode;
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
_fsync = builder.FSync;
_guidRepresentation = builder.GuidRepresentation;
_heartbeatInterval = builder.HeartbeatInterval;
_heartbeatTimeout = builder.HeartbeatTimeout;
_ipv6 = builder.IPv6;
_isResolved = builder.Scheme != ConnectionStringScheme.MongoDBPlusSrv;
_journal = builder.Journal;
_localThreshold = builder.LocalThreshold;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readConcernLevel = builder.ReadConcernLevel;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_retryReads = builder.RetryReads;
_retryWrites = builder.RetryWrites;
_scheme = builder.Scheme;
_servers = builder.Servers;
_serverSelectionTimeout = builder.ServerSelectionTimeout;
_socketTimeout = builder.SocketTimeout;
_username = builder.Username;
_useSsl = builder.UseSsl;
_verifySslCertificate = builder.VerifySslCertificate;
_w = builder.W;
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
public void CreateCommand_should_create_the_correct_command(
[Values("3.0.0", "3.2.0")] string serverVersion,
[Values(null, ReadConcernLevel.Local, ReadConcernLevel.Majority)] ReadConcernLevel?readConcernLevel)
{
var semanticServerVersion = SemanticVersion.Parse(serverVersion);
var filter = new BsonDocument("x", 1);
var hint = "funny";
var limit = 10;
var skip = 30;
var maxTime = TimeSpan.FromSeconds(20);
var subject = new CountOperation(_collectionNamespace, _messageEncoderSettings)
{
Filter = filter,
Hint = hint,
Limit = limit,
MaxTime = maxTime,
ReadConcern = new ReadConcern(readConcernLevel),
Skip = skip
};
var expectedResult = new BsonDocument
{
{ "count", _collectionNamespace.CollectionName },
{ "query", filter },
{ "limit", limit },
{ "skip", skip },
{ "hint", hint },
{ "maxTimeMS", maxTime.TotalMilliseconds }
};
if (!subject.ReadConcern.IsServerDefault)
{
expectedResult["readConcern"] = subject.ReadConcern.ToBsonDocument();
}
if (!subject.ReadConcern.IsSupported(semanticServerVersion))
{
Action act = () => subject.CreateCommand(semanticServerVersion);
act.ShouldThrow <MongoClientException>();
}
else
{
var result = subject.CreateCommand(semanticServerVersion);
result.Should().Be(expectedResult);
}
}
public void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new CountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = subject.CreateCommand(Feature.ReadConcern.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "count", _collectionNamespace.CollectionName },
{ "readConcern", () => readConcern.ToBsonDocument(), !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
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 void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel?level)
{
var readConcern = level.HasValue ? new ReadConcern(level.Value) : ReadConcern.Default;
var subject = new FindCommandOperation <BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = subject.CreateCommand(Feature.ReadConcern.FirstSupportedVersion, 0);
var expectedResult = new BsonDocument
{
{ "find", _collectionNamespace.CollectionName },
{ "readConcern", () => readConcern.ToBsonDocument(), readConcern != null && !readConcern.IsServerDefault }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(supportsSessions: true);
var session = OperationTestHelper.CreateSession(true, new BsonTimestamp(100));
var result = CreateCommand(subject, connectionDescription, session);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
AssertCommandDocument(result, readConcern: expectedReadConcernDocument);
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_allowInsecureTls = false;
_applicationName = null;
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationMechanismProperties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_authenticationSource = null;
_compressors = new CompressorConfiguration[0];
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_heartbeatInterval = ServerSettings.DefaultHeartbeatInterval;
_heartbeatTimeout = ServerSettings.DefaultHeartbeatTimeout;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readConcernLevel = null;
_readPreference = null;
_replicaSetName = null;
_retryReads = null;
_retryWrites = null;
_localThreshold = MongoDefaults.LocalThreshold;
_scheme = ConnectionStringScheme.MongoDB;
_servers = new[] { new MongoServerAddress("localhost", 27017) };
_serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
_socketTimeout = MongoDefaults.SocketTimeout;
_username = null;
_useTls = false;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
public void ReadConcern_document_should_contain_the_expected_values(
[Values(false, true)] bool supportsSessions,
[Values(false, true)] bool causallyConsistent,
[Values(null, 10L)] long?operationTime,
[Values(null, ReadConcernLevel.Majority)] ReadConcernLevel?level)
{
var connectionDescription = OperationTestHelper.CreateConnectionDescription(supportsSessions: supportsSessions);
BsonTimestamp timestamp = operationTime == null ? null : new BsonTimestamp(operationTime.Value);
var session = OperationTestHelper.CreateSession(causallyConsistent, timestamp);
var readConcern = ReadConcern.Default;
if (level != null)
{
readConcern = readConcern.With(level.Value);
}
var command = new BsonDocument();
ReadConcernHelper.AppendReadConcern(command, readConcern, connectionDescription, session);
if ((!supportsSessions || !causallyConsistent || operationTime == null) && level == null)
{
command.ElementCount.Should().Be(0);
}
else
{
command.Contains("readConcern").Should().BeTrue();
}
if (level != null)
{
command["readConcern"]["level"].AsString.Should().Be("majority");
}
if (supportsSessions && causallyConsistent && operationTime != null)
{
command["readConcern"]["afterClusterTime"].AsBsonTimestamp.Value.Should().Be(operationTime.Value);
}
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationMechanismProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
_authenticationSource = null;
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readConcernLevel = null;
_readPreference = null;
_replicaSetName = null;
_localThreshold = MongoDefaults.LocalThreshold;
_servers = new[] { new MongoServerAddress("localhost", 27017) };
_serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
_socketTimeout = MongoDefaults.SocketTimeout;
_username = null;
_useSsl = false;
_verifySslCertificate = true;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(string url)
{
var connectionString = new ConnectionString(url);
_authenticationMechanism = connectionString.AuthMechanism;
_authenticationMechanismProperties = connectionString.AuthMechanismProperties.ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
_authenticationSource = connectionString.AuthSource;
switch (connectionString.Connect)
{
case ClusterConnectionMode.Direct:
_connectionMode = Driver.ConnectionMode.Direct;
break;
case ClusterConnectionMode.ReplicaSet:
_connectionMode = Driver.ConnectionMode.ReplicaSet;
break;
case ClusterConnectionMode.Sharded:
_connectionMode = Driver.ConnectionMode.ShardRouter;
break;
case ClusterConnectionMode.Standalone:
_connectionMode = Driver.ConnectionMode.Standalone;
break;
default:
_connectionMode = Driver.ConnectionMode.Automatic;
break;
}
_connectTimeout = connectionString.ConnectTimeout.GetValueOrDefault(MongoDefaults.ConnectTimeout);
_databaseName = connectionString.DatabaseName;
_fsync = connectionString.FSync;
_guidRepresentation = connectionString.UuidRepresentation.GetValueOrDefault(MongoDefaults.GuidRepresentation);
_ipv6 = connectionString.Ipv6.GetValueOrDefault(false);
_journal = connectionString.Journal;
_maxConnectionIdleTime = connectionString.MaxIdleTime.GetValueOrDefault(MongoDefaults.MaxConnectionIdleTime);
_maxConnectionLifeTime = connectionString.MaxLifeTime.GetValueOrDefault(MongoDefaults.MaxConnectionLifeTime);
_maxConnectionPoolSize = connectionString.MaxPoolSize.GetValueOrDefault(MongoDefaults.MaxConnectionPoolSize);
_minConnectionPoolSize = connectionString.MinPoolSize.GetValueOrDefault(MongoDefaults.MinConnectionPoolSize);
_password = connectionString.Password;
_readConcernLevel = connectionString.ReadConcernLevel;
if (connectionString.ReadPreference != null)
{
_readPreference = new ReadPreference(connectionString.ReadPreference.Value);
}
if (connectionString.ReadPreferenceTags != null)
{
if (_readPreference == null)
{
throw new MongoConfigurationException("ReadPreferenceMode is required when using tag sets.");
}
_readPreference = _readPreference.With(tagSets: connectionString.ReadPreferenceTags);
}
_replicaSetName = connectionString.ReplicaSet;
_localThreshold = connectionString.LocalThreshold.GetValueOrDefault(MongoDefaults.LocalThreshold);
_servers = connectionString.Hosts.Select(endPoint =>
{
DnsEndPoint dnsEndPoint;
IPEndPoint ipEndPoint;
if ((dnsEndPoint = endPoint as DnsEndPoint) != null)
{
return new MongoServerAddress(dnsEndPoint.Host, dnsEndPoint.Port);
}
else if ((ipEndPoint = endPoint as IPEndPoint) != null)
{
var address = ipEndPoint.Address.ToString();
if (ipEndPoint.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
address = "[" + address + "]";
}
return new MongoServerAddress(address, ipEndPoint.Port);
}
else
{
throw new NotSupportedException("Only DnsEndPoint and IPEndPoints are supported in the connection string.");
}
});
_serverSelectionTimeout = connectionString.ServerSelectionTimeout.GetValueOrDefault(MongoDefaults.ServerSelectionTimeout);
_socketTimeout = connectionString.SocketTimeout.GetValueOrDefault(MongoDefaults.SocketTimeout);
_username = connectionString.Username;
_useSsl = connectionString.Ssl.GetValueOrDefault(false);
_verifySslCertificate = connectionString.SslVerifyCertificate.GetValueOrDefault(true);
_w = connectionString.W;
if (connectionString.WaitQueueSize != null)
{
_waitQueueSize = connectionString.WaitQueueSize.Value;
_waitQueueMultiple = 0.0;
}
else if (connectionString.WaitQueueMultiple != null)
{
_waitQueueMultiple = connectionString.WaitQueueMultiple.Value;
_waitQueueSize = 0;
}
_waitQueueTimeout = connectionString.WaitQueueTimeout.GetValueOrDefault(MongoDefaults.WaitQueueTimeout);
_wTimeout = connectionString.WTimeout;
}
