public void TestConnectionMode()
{
var settings = new MongoClientSettings();
Assert.AreEqual(ConnectionMode.Automatic, settings.ConnectionMode);
var connectionMode = ConnectionMode.Direct;
settings.ConnectionMode = connectionMode;
Assert.AreEqual(connectionMode, settings.ConnectionMode);
settings.Freeze();
Assert.AreEqual(connectionMode, settings.ConnectionMode);
Assert.Throws<InvalidOperationException>(() => { settings.ConnectionMode = connectionMode; });
}
public void TestApplicationName()
{
var settings = new MongoClientSettings();
Assert.Equal(null, settings.ApplicationName);
var applicationName = "app";
settings.ApplicationName = applicationName;
Assert.Equal(applicationName, settings.ApplicationName);
settings.Freeze();
Assert.Equal(applicationName, settings.ApplicationName);
Assert.Throws<InvalidOperationException>(() => { settings.ApplicationName = applicationName; });
}
public void TestConnectTimeout()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.ConnectTimeout, settings.ConnectTimeout);
var connectTimeout = new TimeSpan(1, 2, 3);
settings.ConnectTimeout = connectTimeout;
Assert.AreEqual(connectTimeout, settings.ConnectTimeout);
settings.Freeze();
Assert.AreEqual(connectTimeout, settings.ConnectTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.ConnectTimeout = connectTimeout; });
}
public void TestServer()
{
var settings = new MongoClientSettings();
Assert.AreEqual(_localHost, settings.Server);
Assert.IsTrue(new[] { _localHost }.SequenceEqual(settings.Servers));
var server = new MongoServerAddress("server");
var servers = new[] { server };
settings.Server = server;
Assert.AreEqual(server, settings.Server);
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.AreEqual(server, settings.Server);
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
Assert.Throws <InvalidOperationException>(() => { settings.Server = server; });
}
public void TestFreeze()
{
var settings = new MongoClientSettings();
settings.ReadPreference = new ReadPreference();
settings.WriteConcern = new WriteConcern();
Assert.IsFalse(settings.IsFrozen);
Assert.IsFalse(settings.ReadPreference.IsFrozen);
Assert.IsFalse(settings.WriteConcern.IsFrozen);
var hashCode = settings.GetHashCode();
var stringRepresentation = settings.ToString();
settings.Freeze();
Assert.IsTrue(settings.IsFrozen);
Assert.IsTrue(settings.ReadPreference.IsFrozen);
Assert.IsTrue(settings.WriteConcern.IsFrozen);
Assert.AreEqual(hashCode, settings.GetHashCode());
Assert.AreEqual(stringRepresentation, settings.ToString());
}
public void TestServersWithTwoServers()
{
var settings = new MongoClientSettings();
Assert.Equal(_localHost, settings.Server);
Assert.True(new[] { _localHost }.SequenceEqual(settings.Servers));
var servers = new MongoServerAddress[]
{
new MongoServerAddress("server1"),
new MongoServerAddress("server2")
};
settings.Servers = servers;
Assert.Throws <InvalidOperationException>(() => { var s = settings.Server; });
Assert.True(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.Throws <InvalidOperationException>(() => { var s = settings.Server; });
Assert.True(servers.SequenceEqual(settings.Servers));
Assert.Throws <InvalidOperationException>(() => { settings.Servers = servers; });
}
public void TestSslSettings()
{
var settings = new MongoClientSettings();
Assert.AreEqual(null, settings.SslSettings);
var sslSettings = new SslSettings { CheckCertificateRevocation = false };
settings.SslSettings = sslSettings;
Assert.AreEqual(sslSettings, settings.SslSettings);
settings.Freeze();
Assert.AreEqual(sslSettings, settings.SslSettings);
Assert.Throws<InvalidOperationException>(() => { settings.SslSettings = sslSettings; });
}
public void TestServersWithTwoServers()
{
var settings = new MongoClientSettings();
Assert.AreEqual(_localHost, settings.Server);
Assert.IsTrue(new[] { _localHost }.SequenceEqual(settings.Servers));
var servers = new MongoServerAddress[]
{
new MongoServerAddress("server1"),
new MongoServerAddress("server2")
};
settings.Servers = servers;
Assert.Throws<InvalidOperationException>(() => { var s = settings.Server; });
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.Throws<InvalidOperationException>(() => { var s = settings.Server; });
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
Assert.Throws<InvalidOperationException>(() => { settings.Servers = servers; });
}
public void TestLocalThreshold()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.LocalThreshold, settings.LocalThreshold);
var localThreshold = new TimeSpan(1, 2, 3);
settings.LocalThreshold = localThreshold;
Assert.AreEqual(localThreshold, settings.LocalThreshold);
settings.Freeze();
Assert.AreEqual(localThreshold, settings.LocalThreshold);
Assert.Throws<InvalidOperationException>(() => { settings.LocalThreshold = localThreshold; });
}
public void TestReplicaSetName()
{
var settings = new MongoClientSettings();
Assert.AreEqual(null, settings.ReplicaSetName);
var replicaSetName = "abc";
settings.ReplicaSetName = replicaSetName;
Assert.AreSame(replicaSetName, settings.ReplicaSetName);
settings.Freeze();
Assert.AreSame(replicaSetName, settings.ReplicaSetName);
Assert.Throws<InvalidOperationException>(() => { settings.ReplicaSetName = replicaSetName; });
}
public void TestServersWithOneServer()
{
var settings = new MongoClientSettings();
Assert.Equal(_localHost, settings.Server);
Assert.True(new[] { _localHost }.SequenceEqual(settings.Servers));
var server = new MongoServerAddress("server");
var servers = new[] { server };
settings.Servers = servers;
Assert.Equal(server, settings.Server);
Assert.True(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.Equal(server, settings.Server);
Assert.True(servers.SequenceEqual(settings.Servers));
Assert.Throws<InvalidOperationException>(() => { settings.Server = server; });
}
public void TestWriteConcern()
{
var settings = new MongoClientSettings();
Assert.AreEqual(WriteConcern.Acknowledged, settings.WriteConcern);
var writeConcern = new WriteConcern();
settings.WriteConcern = writeConcern;
Assert.AreSame(writeConcern, settings.WriteConcern);
settings.Freeze();
Assert.AreEqual(writeConcern, settings.WriteConcern);
Assert.Throws<InvalidOperationException>(() => { settings.WriteConcern = writeConcern; });
}
public void TestVerifySslCertificate()
{
var settings = new MongoClientSettings();
Assert.AreEqual(true, settings.VerifySslCertificate);
var verifySslCertificate = false;
settings.VerifySslCertificate = verifySslCertificate;
Assert.AreEqual(verifySslCertificate, settings.VerifySslCertificate);
settings.Freeze();
Assert.AreEqual(verifySslCertificate, settings.VerifySslCertificate);
Assert.Throws<InvalidOperationException>(() => { settings.VerifySslCertificate = verifySslCertificate; });
}
public void TestIPv6()
{
var settings = new MongoClientSettings();
Assert.AreEqual(false, settings.IPv6);
var ipv6 = true;
settings.IPv6 = ipv6;
Assert.AreEqual(ipv6, settings.IPv6);
settings.Freeze();
Assert.AreEqual(ipv6, settings.IPv6);
Assert.Throws<InvalidOperationException>(() => { settings.IPv6 = ipv6; });
}
public void TestGuidRepresentation()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.GuidRepresentation, settings.GuidRepresentation);
var guidRepresentation = GuidRepresentation.PythonLegacy;
settings.GuidRepresentation = guidRepresentation;
Assert.AreEqual(guidRepresentation, settings.GuidRepresentation);
settings.Freeze();
Assert.AreEqual(guidRepresentation, settings.GuidRepresentation);
Assert.Throws<InvalidOperationException>(() => { settings.GuidRepresentation = guidRepresentation; });
}
public void TestFreeze()
{
var settings = new MongoClientSettings();
Assert.IsFalse(settings.IsFrozen);
var hashCode = settings.GetHashCode();
var stringRepresentation = settings.ToString();
settings.Freeze();
Assert.IsTrue(settings.IsFrozen);
Assert.AreEqual(hashCode, settings.GetHashCode());
Assert.AreEqual(stringRepresentation, settings.ToString());
}
public void TestWaitQueueTimeout()
{
var settings = new MongoClientSettings();
Assert.Equal(MongoDefaults.WaitQueueTimeout, settings.WaitQueueTimeout);
var waitQueueTimeout = new TimeSpan(1, 2, 3);
settings.WaitQueueTimeout = waitQueueTimeout;
Assert.Equal(waitQueueTimeout, settings.WaitQueueTimeout);
settings.Freeze();
Assert.Equal(waitQueueTimeout, settings.WaitQueueTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.WaitQueueTimeout = waitQueueTimeout; });
}
public void TestServerSelectionTimeout()
{
var settings = new MongoClientSettings();
Assert.Equal(MongoDefaults.ServerSelectionTimeout, settings.ServerSelectionTimeout);
var serverSelectionTimeout = new TimeSpan(1, 2, 3);
settings.ServerSelectionTimeout = serverSelectionTimeout;
Assert.Equal(serverSelectionTimeout, settings.ServerSelectionTimeout);
settings.Freeze();
Assert.Equal(serverSelectionTimeout, settings.ServerSelectionTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.ServerSelectionTimeout = serverSelectionTimeout; });
}
public void TestUseSsl()
{
var settings = new MongoClientSettings();
Assert.AreEqual(false, settings.UseSsl);
var useSsl = true;
settings.UseSsl = useSsl;
Assert.AreEqual(useSsl, settings.UseSsl);
settings.Freeze();
Assert.AreEqual(useSsl, settings.UseSsl);
Assert.Throws<InvalidOperationException>(() => { settings.UseSsl = useSsl; });
}
public void TestHeartbeatTimeout()
{
var settings = new MongoClientSettings();
Assert.Equal(ServerSettings.DefaultHeartbeatTimeout, settings.HeartbeatTimeout);
var heartbeatTimeout = new TimeSpan(1, 2, 3);
settings.HeartbeatTimeout = heartbeatTimeout;
Assert.Equal(heartbeatTimeout, settings.HeartbeatTimeout);
settings.Freeze();
Assert.Equal(heartbeatTimeout, settings.HeartbeatTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.HeartbeatTimeout = heartbeatTimeout; });
}
public void TestMinConnectionPoolSize()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, settings.MinConnectionPoolSize);
var minConnectionPoolSize = 123;
settings.MinConnectionPoolSize = minConnectionPoolSize;
Assert.AreEqual(minConnectionPoolSize, settings.MinConnectionPoolSize);
settings.Freeze();
Assert.AreEqual(minConnectionPoolSize, settings.MinConnectionPoolSize);
Assert.Throws<InvalidOperationException>(() => { settings.MinConnectionPoolSize = minConnectionPoolSize; });
}
public void TestWaitQueueSize()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, settings.WaitQueueSize);
var waitQueueSize = 123;
settings.WaitQueueSize = waitQueueSize;
Assert.AreEqual(waitQueueSize, settings.WaitQueueSize);
settings.Freeze();
Assert.AreEqual(waitQueueSize, settings.WaitQueueSize);
Assert.Throws<InvalidOperationException>(() => { settings.WaitQueueSize = waitQueueSize; });
}
public void TestReadPreference()
{
var settings = new MongoClientSettings();
Assert.AreEqual(ReadPreference.Primary, settings.ReadPreference);
var readPreference = ReadPreference.Primary;
settings.ReadPreference = readPreference;
Assert.AreSame(readPreference, settings.ReadPreference);
settings.Freeze();
Assert.AreEqual(readPreference, settings.ReadPreference);
Assert.Throws<InvalidOperationException>(() => { settings.ReadPreference = readPreference; });
}
public void TestMaxConnectionLifeTime()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
var maxConnectionLifeTime = new TimeSpan(1, 2, 3);
settings.MaxConnectionLifeTime = maxConnectionLifeTime;
Assert.AreEqual(maxConnectionLifeTime, settings.MaxConnectionLifeTime);
settings.Freeze();
Assert.AreEqual(maxConnectionLifeTime, settings.MaxConnectionLifeTime);
Assert.Throws<InvalidOperationException>(() => { settings.MaxConnectionLifeTime = maxConnectionLifeTime; });
}
public void TestReadConcern()
{
var settings = new MongoClientSettings();
Assert.Equal(ReadConcern.Default, settings.ReadConcern);
var readConcern = ReadConcern.Majority;
settings.ReadConcern = readConcern;
Assert.Same(readConcern, settings.ReadConcern);
settings.Freeze();
Assert.Equal(readConcern, settings.ReadConcern);
Assert.Throws<InvalidOperationException>(() => { settings.ReadConcern = ReadConcern.Default; });
}
