public void GetOrCreateCluster_should_return_a_cluster_with_the_correct_settings()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost"), new MongoServerAddress("127.0.0.1", 30000), new MongoServerAddress("[::1]", 27018) };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Tls
};
var clientSettings = new MongoClientSettings
{
ApplicationName = "app1",
ConnectionMode = ConnectionMode.ReplicaSet,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
HeartbeatInterval = TimeSpan.FromSeconds(7),
HeartbeatTimeout = TimeSpan.FromSeconds(8),
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
LocalThreshold = TimeSpan.FromMilliseconds(20),
Servers = servers,
ServerSelectionTimeout = TimeSpan.FromSeconds(5),
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(6)
};
var subject = new ClusterRegistry();
using (var cluster = subject.GetOrCreateCluster(clientSettings.ToClusterKey()))
{
var endPoints = new EndPoint[]
{
new DnsEndPoint("localhost", 27017),
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 30000),
new IPEndPoint(IPAddress.Parse("[::1]"), 27018)
};
cluster.Settings.ConnectionMode.Should().Be(ClusterConnectionMode.ReplicaSet);
cluster.Settings.EndPoints.Equals(endPoints);
cluster.Settings.ReplicaSetName.Should().Be("rs");
cluster.Settings.ServerSelectionTimeout.Should().Be(clientSettings.ServerSelectionTimeout);
cluster.Settings.PostServerSelector.Should().NotBeNull().And.Subject.Should().BeOfType<LatencyLimitingServerSelector>();
cluster.Settings.MaxServerSelectionWaitQueueSize.Should().Be(20);
cluster.Description.Servers.Select(s => s.EndPoint).Should().Contain(endPoints);
// TODO: don't know how to test the rest of the settings because they are all private to the cluster
}
}
public void TestEquals()
{
var settings = new SslSettings();
var clone = settings.Clone();
Assert.Equal(settings, clone);
clone = settings.Clone();
clone.CheckCertificateRevocation = !settings.CheckCertificateRevocation;
Assert.NotEqual(settings, clone);
clone = settings.Clone();
var certificateFileName = GetTestCertificateFileName();
clone.ClientCertificates = new[] { new X509Certificate2(certificateFileName, "password") };
Assert.NotEqual(settings, clone);
clone = settings.Clone();
clone.ClientCertificateSelectionCallback = ClientCertificateSelectionCallback;
Assert.NotEqual(settings, clone);
clone = settings.Clone();
clone.EnabledSslProtocols = SslProtocols.Tls12;
Assert.NotEqual(settings, clone);
clone = settings.Clone();
clone.ServerCertificateValidationCallback = ServerCertificateValidationCallback;
Assert.NotEqual(settings, clone);
}
// constructors
public ClusterKey(MongoClientSettings clientSettings)
{
_clusterConfigurator = clientSettings.ClusterConfigurator;
_connectionMode = clientSettings.ConnectionMode;
_connectTimeout = clientSettings.ConnectTimeout;
_credentials = clientSettings.Credentials.ToList();
_heartbeatInterval = __defaultHeartbeatInterval; // TODO: add HeartbeatInterval to MongoClientSettings?
_heartbeatTimeout = __defaultHeartbeatTimeout; // TODO: add HeartbeatTimeout to MongoClientSettings?
_ipv6 = clientSettings.IPv6;
_localThreshold = clientSettings.LocalThreshold;
_maxConnectionIdleTime = clientSettings.MaxConnectionIdleTime;
_maxConnectionLifeTime = clientSettings.MaxConnectionLifeTime;
_maxConnectionPoolSize = clientSettings.MaxConnectionPoolSize;
_minConnectionPoolSize = clientSettings.MinConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoClientSettings?
_replicaSetName = clientSettings.ReplicaSetName;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoClientSettings?
_servers = clientSettings.Servers.ToList();
_socketTimeout = clientSettings.SocketTimeout;
_sslSettings = clientSettings.SslSettings;
_useSsl = clientSettings.UseSsl;
_verifySslCertificate = clientSettings.VerifySslCertificate;
_waitQueueSize = clientSettings.WaitQueueSize;
_waitQueueTimeout = clientSettings.WaitQueueTimeout;
_hashCode = CalculateHashCode();
}
public ClusterKey(MongoServerSettings serverSettings)
{
_connectionMode = serverSettings.ConnectionMode;
_connectTimeout = serverSettings.ConnectTimeout;
_credentials = serverSettings.Credentials.ToList();
_heartbeatInterval = __defaultHeartbeatInterval; // TODO: add HeartbeatInterval to MongoServerSettings?
_heartbeatTimeout = __defaultHeartbeatTimeout; // TODO: add HeartbeatTimeout to MongoServerSettings?
_ipv6 = serverSettings.IPv6;
_maxConnectionIdleTime = serverSettings.MaxConnectionIdleTime;
_maxConnectionLifeTime = serverSettings.MaxConnectionLifeTime;
_maxConnectionPoolSize = serverSettings.MaxConnectionPoolSize;
_minConnectionPoolSize = serverSettings.MinConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoServerSettings?
_replicaSetName = serverSettings.ReplicaSetName;
_secondaryAcceptableLatency = serverSettings.SecondaryAcceptableLatency;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoServerSettings?
_servers = serverSettings.Servers.ToList();
_socketTimeout = serverSettings.SocketTimeout;
_sslSettings = serverSettings.SslSettings;
_useSsl = serverSettings.UseSsl;
_verifySslCertificate = serverSettings.VerifySslCertificate;
_waitQueueSize = serverSettings.WaitQueueSize;
_waitQueueTimeout = serverSettings.WaitQueueTimeout;
_hashCode = CalculateHashCode();
}
public void SetSslOptions(SslSettings ssl)
{
foreach (var endpoint in _amqpTcpEndpoints)
{
endpoint.Ssl = ToSslOption(ssl);
}
}
public void GetOrCreateCluster_should_return_a_cluster_with_the_correct_settings()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost"), new MongoServerAddress("127.0.0.1", 30000), new MongoServerAddress("[::1]", 27018) };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Tls
};
var clientSettings = new MongoClientSettings
{
ApplicationName = "app1",
ConnectionMode = ConnectionMode.ReplicaSet,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
HeartbeatInterval = TimeSpan.FromSeconds(7),
HeartbeatTimeout = TimeSpan.FromSeconds(8),
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
LocalThreshold = TimeSpan.FromMilliseconds(20),
Servers = servers,
ServerSelectionTimeout = TimeSpan.FromSeconds(5),
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(6)
};
var subject = new ClusterRegistry();
using (var cluster = subject.GetOrCreateCluster(clientSettings.ToClusterKey()))
{
var endPoints = new EndPoint[]
{
new DnsEndPoint("localhost", 27017),
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 30000),
new IPEndPoint(IPAddress.Parse("[::1]"), 27018)
};
cluster.Settings.ConnectionMode.Should().Be(ClusterConnectionMode.ReplicaSet);
cluster.Settings.EndPoints.Equals(endPoints);
cluster.Settings.ReplicaSetName.Should().Be("rs");
cluster.Settings.ServerSelectionTimeout.Should().Be(clientSettings.ServerSelectionTimeout);
cluster.Settings.PostServerSelector.Should().NotBeNull().And.Subject.Should().BeOfType <LatencyLimitingServerSelector>();
cluster.Settings.MaxServerSelectionWaitQueueSize.Should().Be(20);
cluster.Description.Servers.Select(s => s.EndPoint).Should().Contain(endPoints);
// TODO: don't know how to test the rest of the settings because they are all private to the cluster
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MongoDbRepository<T, TKey>"/> class.
/// </summary>
/// <param name="connectionString">The connectionString of the MongoDb instance.</param>
/// <param name="sslSettings">Ssl Settings for mongo connection</param>
/// <param name="cachingStrategy">The caching strategy. Defaults to <see cref="NoCachingStrategy<T, TKey>" />.</param>
public MongoDbRepository(string connectionString, SslSettings sslSettings, ICachingStrategy <T, TKey> cachingStrategy = null)
: base(connectionString, cachingStrategy, sslSettings)
{
if (String.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException("connectionString");
}
}
public static Builder Create(SslSettings sslSettings, string frejaEnvironment)
{
if (sslSettings == null)
{
throw new FrejaEidClientInternalException(message: "SslSettings cannot be null.");
}
return(new Builder(sslSettings.KeystorePath, sslSettings.KeystorePass, sslSettings.ServerCertificatePath, frejaEnvironment));
}
private SslStreamSettings GetTlsStreamSettings(string kmsProvider)
{
if (!_tlsOptions.TryGetValue(kmsProvider, out var tlsSettings))
{
// default settings
tlsSettings = new SslSettings();
}
return(Ensure.IsNotNull(tlsSettings, nameof(tlsSettings)).ToSslStreamSettings());
}
public Listener(string host, int port, SslSettings sslSettings)
{
_ = host ?? throw new ArgumentNullException();
_port = port > 0 && port <= 65535 ? port : throw new ArgumentOutOfRangeException();
_sslSettings = sslSettings;
_cts = new CancellationTokenSource();
_listeners = new List <ITcpListener>();
_addresses = Utilities.ParseHost(host);
}
public void TestDefaults()
{
var settings = new SslSettings();
Assert.Equal(true, settings.CheckCertificateRevocation);
Assert.Equal(null, settings.ClientCertificates);
Assert.Equal(null, settings.ClientCertificateSelectionCallback);
Assert.Equal(SslProtocols.Default, settings.EnabledSslProtocols);
Assert.Equal(null, settings.ServerCertificateValidationCallback);
}
public void TestDefaults()
{
var settings = new SslSettings();
settings.CheckCertificateRevocation.Should().BeFalse();
Assert.Equal(null, settings.ClientCertificates);
Assert.Equal(null, settings.ClientCertificateSelectionCallback);
Assert.Equal(SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls, settings.EnabledSslProtocols);
Assert.Equal(null, settings.ServerCertificateValidationCallback);
}
public void ToClusterKey_should_copy_relevant_values()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Ssl3
};
var subject = new MongoClientSettings
{
ConnectionMode = ConnectionMode.Direct,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
LocalThreshold = TimeSpan.FromMilliseconds(20),
Servers = servers,
ServerSelectionTimeout = TimeSpan.FromSeconds(6),
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var result = subject.ToClusterKey();
result.ConnectionMode.Should().Be(subject.ConnectionMode);
result.ConnectTimeout.Should().Be(subject.ConnectTimeout);
result.Credentials.Should().Equal(subject.Credentials);
result.IPv6.Should().Be(subject.IPv6);
result.MaxConnectionIdleTime.Should().Be(subject.MaxConnectionIdleTime);
result.MaxConnectionLifeTime.Should().Be(subject.MaxConnectionLifeTime);
result.MaxConnectionPoolSize.Should().Be(subject.MaxConnectionPoolSize);
result.MinConnectionPoolSize.Should().Be(subject.MinConnectionPoolSize);
result.ReplicaSetName.Should().Be(subject.ReplicaSetName);
result.LocalThreshold.Should().Be(subject.LocalThreshold);
result.Servers.Should().Equal(subject.Servers);
result.ServerSelectionTimeout.Should().Be(subject.ServerSelectionTimeout);
result.SocketTimeout.Should().Be(subject.SocketTimeout);
result.SslSettings.Should().Be(subject.SslSettings);
result.UseSsl.Should().Be(subject.UseSsl);
result.VerifySslCertificate.Should().Be(subject.VerifySslCertificate);
result.WaitQueueSize.Should().Be(subject.WaitQueueSize);
result.WaitQueueTimeout.Should().Be(subject.WaitQueueTimeout);
}
public void Constructor_with_MongoServerSettings_parameter_should_copy_relevant_values()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var certificates = new[] { new X509Certificate() };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
ClientCertificates = certificates,
EnabledSslProtocols = SslProtocols.Tls12
};
var serverSettings = new MongoServerSettings
{
ConnectionMode = ConnectionMode.Direct,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
Servers = servers,
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var subject = new ClusterKey(serverSettings);
subject.ConnectionMode.Should().Be(serverSettings.ConnectionMode);
subject.ConnectTimeout.Should().Be(serverSettings.ConnectTimeout);
subject.Credentials.Should().Equal(serverSettings.Credentials);
subject.IPv6.Should().Be(serverSettings.IPv6);
subject.MaxConnectionIdleTime.Should().Be(serverSettings.MaxConnectionIdleTime);
subject.MaxConnectionLifeTime.Should().Be(serverSettings.MaxConnectionLifeTime);
subject.MaxConnectionPoolSize.Should().Be(serverSettings.MaxConnectionPoolSize);
subject.MinConnectionPoolSize.Should().Be(serverSettings.MinConnectionPoolSize);
subject.ReplicaSetName.Should().Be(serverSettings.ReplicaSetName);
subject.Servers.Should().Equal(serverSettings.Servers);
subject.SocketTimeout.Should().Be(serverSettings.SocketTimeout);
subject.SslSettings.Should().Be(serverSettings.SslSettings);
subject.UseSsl.Should().Be(serverSettings.UseSsl);
subject.VerifySslCertificate.Should().Be(serverSettings.VerifySslCertificate);
subject.WaitQueueSize.Should().Be(serverSettings.WaitQueueSize);
subject.WaitQueueTimeout.Should().Be(serverSettings.WaitQueueTimeout);
}
public static RabbitMqOptionsBuilder ConfigureSsl(this RabbitMqOptionsBuilder builder, string connectionString)
{
var uri = new Uri(connectionString);
if (uri.Scheme.Equals("amqps", StringComparison.InvariantCultureIgnoreCase))
{
var sslSettings = new SslSettings(true, uri.Host);
builder.Ssl(sslSettings);
}
return(builder);
}
public void Constructor_with_MongoClientSettings_parameter_should_copy_relevant_values()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var certificates = new[] { new X509Certificate() };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
ClientCertificates = certificates,
EnabledSslProtocols = SslProtocols.Tls12
};
var clientSettings = new MongoClientSettings
{
ConnectionMode = ConnectionMode.Direct,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
Servers = servers,
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var subject = new ClusterKey(clientSettings);
subject.ConnectionMode.Should().Be(clientSettings.ConnectionMode);
subject.ConnectTimeout.Should().Be(clientSettings.ConnectTimeout);
subject.Credentials.Should().Equal(clientSettings.Credentials);
subject.IPv6.Should().Be(clientSettings.IPv6);
subject.MaxConnectionIdleTime.Should().Be(clientSettings.MaxConnectionIdleTime);
subject.MaxConnectionLifeTime.Should().Be(clientSettings.MaxConnectionLifeTime);
subject.MaxConnectionPoolSize.Should().Be(clientSettings.MaxConnectionPoolSize);
subject.MinConnectionPoolSize.Should().Be(clientSettings.MinConnectionPoolSize);
subject.ReplicaSetName.Should().Be(clientSettings.ReplicaSetName);
subject.Servers.Should().Equal(clientSettings.Servers);
subject.SocketTimeout.Should().Be(clientSettings.SocketTimeout);
subject.SslSettings.Should().Be(clientSettings.SslSettings);
subject.UseSsl.Should().Be(clientSettings.UseSsl);
subject.VerifySslCertificate.Should().Be(clientSettings.VerifySslCertificate);
subject.WaitQueueSize.Should().Be(clientSettings.WaitQueueSize);
subject.WaitQueueTimeout.Should().Be(clientSettings.WaitQueueTimeout);
}
public void TestCheckCertificateRevocation()
{
var settings = new SslSettings();
Assert.AreEqual(true, settings.CheckCertificateRevocation);
var checkCertificateRevocation = !settings.CheckCertificateRevocation;
settings.CheckCertificateRevocation = checkCertificateRevocation;
Assert.AreEqual(checkCertificateRevocation, settings.CheckCertificateRevocation);
settings.Freeze();
Assert.AreEqual(checkCertificateRevocation, settings.CheckCertificateRevocation);
Assert.Throws<InvalidOperationException>(() => { settings.CheckCertificateRevocation = checkCertificateRevocation; });
}
private void AuthClientInit_assertError(string keyStorePath, string password, string certificatePath, string errorMessage)
{
try
{
AuthenticationClient.Create(SslSettings.Create(keyStorePath, password, certificatePath), FrejaEnvironment.TEST)
.Build <AuthenticationClient>();
Assert.Fail("Test should throw exception!");
}
catch (FrejaEidClientInternalException ex)
{
Assert.AreEqual(errorMessage, ex.Message);
}
}
public void TestInitialize()
{
jsonService = new JsonService();
initiateAuthenticationResponse = new InitiateAuthenticationResponse(REFERENCE);
authenticationResult = new AuthenticationResult(REFERENCE, TransactionStatus.STARTED, null, null);
authenticationResultWithRequestedAttributes = new AuthenticationResult(REFERENCE, TransactionStatus.APPROVED, DETAILS, REQUESTED_ATTRIBUTES);
authenticationResults = new AuthenticationResults(new List <AuthenticationResult> {
authenticationResult
});
authenticationClient = AuthenticationClient.Create(SslSettings.Create(TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.KEYSTORE_PATH_PKCS12), TestKeystoreUtil.KEYSTORE_PASSWORD, TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.CERTIFICATE_PATH)), FrejaEnvironment.TEST)
.SetTestModeCustomUrl(CUSTOM_URL).SetTransactionContext(TransactionContext.PERSONAL).Build <AuthenticationClient>();
StopServer();
}
public void TestClientCertificateSelectionCallback()
{
var settings = new SslSettings();
Assert.AreEqual(null, settings.ClientCertificateSelectionCallback);
var callback = (LocalCertificateSelectionCallback)ClientCertificateSelectionCallback;
settings.ClientCertificateSelectionCallback = callback;
Assert.AreEqual(callback, settings.ClientCertificateSelectionCallback);
settings.Freeze();
Assert.AreEqual(callback, settings.ClientCertificateSelectionCallback);
Assert.Throws<InvalidOperationException>(() => { settings.ClientCertificateSelectionCallback = callback; });
}
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; });
}
// constructors
public ClusterKey(
string applicationName,
Action<ClusterBuilder> clusterConfigurator,
ConnectionMode connectionMode,
TimeSpan connectTimeout,
IReadOnlyList<MongoCredential> credentials,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
bool ipv6,
TimeSpan localThreshold,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
string replicaSetName,
IReadOnlyList<MongoServerAddress> servers,
TimeSpan serverSelectionTimeout,
TimeSpan socketTimeout,
SslSettings sslSettings,
bool useSsl,
bool verifySslCertificate,
int waitQueueSize,
TimeSpan waitQueueTimeout)
{
_applicationName = applicationName;
_clusterConfigurator = clusterConfigurator;
_connectionMode = connectionMode;
_connectTimeout = connectTimeout;
_credentials = credentials;
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_ipv6 = ipv6;
_localThreshold = localThreshold;
_maxConnectionIdleTime = maxConnectionIdleTime;
_maxConnectionLifeTime = maxConnectionLifeTime;
_maxConnectionPoolSize = maxConnectionPoolSize;
_minConnectionPoolSize = minConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoServerSettings?
_replicaSetName = replicaSetName;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoServerSettings?
_servers = servers;
_serverSelectionTimeout = serverSelectionTimeout;
_socketTimeout = socketTimeout;
_sslSettings = sslSettings;
_useSsl = useSsl;
_verifySslCertificate = verifySslCertificate;
_waitQueueSize = waitQueueSize;
_waitQueueTimeout = waitQueueTimeout;
_hashCode = CalculateHashCode();
}
private static bool IsRequestProtected(string path, string appPath, SslSettings settings)
{
var match = false;
var sr = new StringReader(settings.Urls ?? "");
string pattern;
while (!match && null != (pattern = sr.ReadLine()))
{
pattern = pattern.Trim();
match = IsMatched(pattern, path, appPath);
}
return(match);
}
private void RelyingPartyNull_success(InitiateAuthenticationRequest initiateAuthenticationRequest)
{
InitiateAuthenticationResponse expectedResponse = new InitiateAuthenticationResponse(CommonTestData.REFERENCE);
CommonTestData.HttpServiceMock.Setup(x => x.Send <InitiateAuthenticationResponse>(It.IsAny <Uri>(), It.IsAny <string>(), It.IsAny <InitiateAuthenticationRequest>(), null)).Returns(expectedResponse);
IAuthenticationClient authenticationClient = AuthenticationClient.Create(SslSettings.Create(TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.KEYSTORE_PATH_PKCS12), TestKeystoreUtil.KEYSTORE_PASSWORD, TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.CERTIFICATE_PATH)), FrejaEnvironment.TEST)
.SetHttpService(CommonTestData.HttpServiceMock.Object)
.SetTransactionContext(TransactionContext.PERSONAL).Build <AuthenticationClient>();
string reference = authenticationClient.Initiate(initiateAuthenticationRequest);
CommonTestData.HttpServiceMock.Verify(x => x.Send <InitiateAuthenticationResponse>(new Uri(FrejaEnvironment.TEST + MethodUrl.AUTHENTICATION_INIT), RequestTemplate.INIT_AUTHENTICATION_TEMPLATE, initiateAuthenticationRequest, null));
Assert.AreEqual(CommonTestData.REFERENCE, reference);
}
public void GetOrCreateCluster_should_return_a_cluster_with_the_correct_settings()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Ssl3
};
var clientSettings = new MongoClientSettings
{
ConnectionMode = ConnectionMode.ReplicaSet,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
SecondaryAcceptableLatency = TimeSpan.FromMilliseconds(20),
Servers = servers,
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var subject = new ClusterRegistry();
using (var cluster = subject.GetOrCreateCluster(clientSettings))
{
var address = clientSettings.Servers.Single();
var endPoints = new[] { new DnsEndPoint(address.Host, address.Port) };
cluster.Settings.ConnectionMode.Should().Be(ClusterConnectionMode.ReplicaSet);
cluster.Settings.EndPoints.Equals(endPoints);
cluster.Settings.ReplicaSetName.Should().Be("rs");
cluster.Settings.PostServerSelector.Should().NotBeNull().And.Subject.Should().BeOfType <LatencyLimitingServerSelector>();
var serverDescription = cluster.Description.Servers.Single(s => s.EndPoint.Equals(endPoints[0]));
serverDescription.EndPoint.Should().Be(endPoints[0]);
// TODO: don't know how to test the rest of the settings because they are all private to the cluster
}
}
public void GetOrCreateCluster_should_return_a_cluster_with_the_correct_settings()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var certificates = new[] { new X509Certificate() };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
ClientCertificates = certificates,
EnabledSslProtocols = SslProtocols.Tls12
};
var clientSettings = new MongoClientSettings
{
ConnectionMode = ConnectionMode.ReplicaSet,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
Servers = servers,
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var subject = new ClusterRegistry();
using (var cluster = subject.GetOrCreateCluster(clientSettings))
{
var address = clientSettings.Servers.Single();
var endPoints = new[] { new DnsEndPoint(address.Host, address.Port) };
cluster.Settings.ConnectionMode.Should().Be(ClusterConnectionMode.ReplicaSet);
cluster.Settings.EndPoints.Equals(endPoints);
cluster.Settings.ReplicaSetName.Should().Be("rs");
var serverDescription = cluster.Description.Servers.Single(s => s.EndPoint.Equals(endPoints[0]));
serverDescription.EndPoint.Should().Be(endPoints[0]);
// TODO: don't know how to test the rest of the settings because they are all private to the cluster
}
}
public void AuthClientInit_invalidPoolingTime_expectError()
{
try
{
AuthenticationClient.Create(SslSettings.Create(TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.KEYSTORE_PATH_PKCS12), TestKeystoreUtil.KEYSTORE_PASSWORD, TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.CERTIFICATE_PATH)), FrejaEnvironment.TEST)
.SetPollingTimeout(INVALID_POLLING_TIMEOUT)
.Build <AuthenticationClient>();
Assert.Fail("Test should throw exception!");
}
catch (FrejaEidClientInternalException ex)
{
Assert.AreEqual("Polling timeout must be between 1 and 30 seconds.", ex.Message);
}
}
public void TestClone()
{
var settings = new SslSettings
{
CheckCertificateRevocation = false,
ClientCertificates = new[] { new X509Certificate2("testcert.pfx", "password") },
ClientCertificateSelectionCallback = ClientCertificateSelectionCallback,
EnabledSslProtocols = SslProtocols.Tls,
ServerCertificateValidationCallback = ServerCertificateValidationCallback
};
var clone = settings.Clone();
Assert.AreEqual(settings, clone);
}
public void TestClientCertificateSelectionCallback()
{
var settings = new SslSettings();
Assert.Equal(null, settings.ClientCertificateSelectionCallback);
var callback = (LocalCertificateSelectionCallback)ClientCertificateSelectionCallback;
settings.ClientCertificateSelectionCallback = callback;
Assert.Equal(callback, settings.ClientCertificateSelectionCallback);
settings.Freeze();
Assert.Equal(callback, settings.ClientCertificateSelectionCallback);
Assert.Throws <InvalidOperationException>(() => { settings.ClientCertificateSelectionCallback = callback; });
}
public void TestCheckCertificateRevocation()
{
var settings = new SslSettings();
settings.CheckCertificateRevocation.Should().BeFalse();
var checkCertificateRevocation = !settings.CheckCertificateRevocation;
settings.CheckCertificateRevocation = checkCertificateRevocation;
Assert.Equal(checkCertificateRevocation, settings.CheckCertificateRevocation);
settings.Freeze();
Assert.Equal(checkCertificateRevocation, settings.CheckCertificateRevocation);
Assert.Throws <InvalidOperationException>(() => { settings.CheckCertificateRevocation = checkCertificateRevocation; });
}
public void TestClientCertificates()
{
var settings = new SslSettings();
Assert.AreEqual(null, settings.ClientCertificates);
var clientCertificates = new[] { new X509Certificate2("testcert.pfx", "password"), new X509Certificate2("testcert.pfx", "password") };
settings.ClientCertificates = clientCertificates;
Assert.IsTrue(clientCertificates.SequenceEqual(settings.ClientCertificates));
Assert.AreNotSame(clientCertificates[0], settings.ClientCertificates.ElementAt(0));
Assert.AreNotSame(clientCertificates[1], settings.ClientCertificates.ElementAt(1));
settings.Freeze();
Assert.IsTrue(clientCertificates.SequenceEqual(settings.ClientCertificates));
Assert.Throws<InvalidOperationException>(() => { settings.ClientCertificates = clientCertificates; });
}
public void TestEnabledSslProtocols()
{
var settings = new SslSettings();
Assert.Equal(SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls, settings.EnabledSslProtocols);
var enabledSslProtocols = SslProtocols.Tls;
settings.EnabledSslProtocols = enabledSslProtocols;
Assert.Equal(enabledSslProtocols, settings.EnabledSslProtocols);
settings.Freeze();
Assert.Equal(enabledSslProtocols, settings.EnabledSslProtocols);
Assert.Throws <InvalidOperationException>(() => { settings.EnabledSslProtocols = enabledSslProtocols; });
}
public void TestServerCertificateValidationCallback()
{
var settings = new SslSettings();
Assert.Equal(null, settings.ServerCertificateValidationCallback);
var callback = (RemoteCertificateValidationCallback)ServerCertificateValidationCallback;
settings.ServerCertificateValidationCallback = callback;
Assert.Equal(callback, settings.ServerCertificateValidationCallback);
settings.Freeze();
Assert.Equal(callback, settings.ServerCertificateValidationCallback);
Assert.Throws <InvalidOperationException>(() => { settings.ServerCertificateValidationCallback = callback; });
}
public void TestDefaults()
{
var settings = new SslSettings();
Assert.Equal(true, settings.CheckCertificateRevocation);
Assert.Equal(null, settings.ClientCertificates);
Assert.Equal(null, settings.ClientCertificateSelectionCallback);
#if NETSTANDARD1_6
#pragma warning disable 618
Assert.Equal(SslProtocols.Tls | SslProtocols.Ssl3, settings.EnabledSslProtocols);
#pragma warning restore
#else
Assert.Equal(SslProtocols.Default, settings.EnabledSslProtocols);
#endif
Assert.Equal(null, settings.ServerCertificateValidationCallback);
}
static SslOption ToSslOption(SslSettings ssl)
{
if (ssl == null)
{
return(new SslOption());
}
var sslOption = new SslOption(ssl.ServerName, ssl.CertPath, ssl.Enabled)
{
CertPassphrase = ssl.CertPassphrase,
Version = ssl.Version,
AcceptablePolicyErrors = ssl.AcceptablePolicyErrors
};
return(sslOption);
}
public void TestSslSettings()
{
var settings = new MongoServerSettings();
settings.SslSettings.Should().BeNull();
var sslSettings = new SslSettings {
CheckCertificateRevocation = false
};
settings.SslSettings = sslSettings;
Assert.Equal(sslSettings, settings.SslSettings);
settings.Freeze();
Assert.Equal(sslSettings, settings.SslSettings);
Assert.Throws <InvalidOperationException>(() => { settings.SslSettings = sslSettings; });
}
public void InitAuth_organisationalTransaction_success()
{
AuthenticationClient authenticationClient = AuthenticationClient.Create(SslSettings.Create(TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.KEYSTORE_PATH_PKCS12), TestKeystoreUtil.KEYSTORE_PASSWORD, TestKeystoreUtil.GetKeystorePath(TestKeystoreUtil.CERTIFICATE_PATH)), FrejaEnvironment.TEST)
.SetTestModeCustomUrl(CUSTOM_URL).SetTransactionContext(TransactionContext.ORGANISATIONAL).Build <AuthenticationClient>();
InitiateAuthenticationRequest initAuthenticationRequestWithRequestedAttributesUserInfoOrganisationId = InitiateAuthenticationRequest.CreateCustom()
.SetOrganisationId(ORGANISATION_ID)
.SetAttributesToReturn(AttributeToReturn.BASIC_USER_INFO, AttributeToReturn.EMAIL_ADDRESS, AttributeToReturn.SSN, AttributeToReturn.CUSTOM_IDENTIFIER, AttributeToReturn.INTEGRATOR_SPECIFIC_USER_ID, AttributeToReturn.ORGANISATION_ID_IDENTIFIER)
.Build();
String initAuthResponseString = jsonService.SerializeToJson(initiateAuthenticationResponse);
StartMockServer(initAuthenticationRequestWithRequestedAttributesUserInfoOrganisationId, (int)HttpStatusCode.OK, initAuthResponseString);
String reference = authenticationClient.Initiate(initAuthenticationRequestWithRequestedAttributesUserInfoOrganisationId);
StopServer();
Assert.AreEqual(REFERENCE, reference);
}
public void TestEnabledSslProtocols()
{
var settings = new SslSettings();
Assert.AreEqual(SslProtocols.Default, settings.EnabledSslProtocols);
var enabledSslProtocols = SslProtocols.Tls;
settings.EnabledSslProtocols = enabledSslProtocols;
Assert.AreEqual(enabledSslProtocols, settings.EnabledSslProtocols);
settings.Freeze();
Assert.AreEqual(enabledSslProtocols, settings.EnabledSslProtocols);
Assert.Throws<InvalidOperationException>(() => { settings.EnabledSslProtocols = enabledSslProtocols; });
}
public ClusterKey(MongoServerSettings serverSettings)
{
_connectionMode = serverSettings.ConnectionMode;
_connectTimeout = serverSettings.ConnectTimeout;
_credentials = serverSettings.Credentials.ToList();
_heartbeatInterval = __defaultHeartbeatInterval; // TODO: add HeartbeatInterval to MongoServerSettings?
_heartbeatTimeout = __defaultHeartbeatTimeout; // TODO: add HeartbeatTimeout to MongoServerSettings?
_ipv6 = serverSettings.IPv6;
_maxConnectionIdleTime = serverSettings.MaxConnectionIdleTime;
_maxConnectionLifeTime = serverSettings.MaxConnectionLifeTime;
_maxConnectionPoolSize = serverSettings.MaxConnectionPoolSize;
_minConnectionPoolSize = serverSettings.MinConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoServerSettings?
_replicaSetName = serverSettings.ReplicaSetName;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoServerSettings?
_servers = serverSettings.Servers.ToList();
_socketTimeout = serverSettings.SocketTimeout;
_sslSettings = serverSettings.SslSettings;
_useSsl = serverSettings.UseSsl;
_verifySslCertificate = serverSettings.VerifySslCertificate;
_waitQueueSize = serverSettings.WaitQueueSize;
_waitQueueTimeout = serverSettings.WaitQueueTimeout;
_hashCode = CalculateHashCode();
}
private ClusterKey CreateSubject(string notEqualFieldName = null)
{
var connectionMode = ConnectionMode.Direct;
var connectTimeout = TimeSpan.FromSeconds(1);
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var guidRepresentation = GuidRepresentation.Standard;
var ipv6 = false;
var localThreshold = TimeSpan.FromMilliseconds(20);
var maxConnectionIdleTime = TimeSpan.FromSeconds(2);
var maxConnectionLifeTime = TimeSpan.FromSeconds(3);
var maxConnectionPoolSize = 50;
var minConnectionPoolSize = 5;
var replicaSetName = "abc";
var servers = new[] { new MongoServerAddress("localhost") };
var serverSelectionTimeout = TimeSpan.FromSeconds(6);
var socketTimeout = TimeSpan.FromSeconds(4);
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Ssl3
};
var useSsl = false;
var verifySslCertificate = false;
var waitQueueSize = 20;
var waitQueueTimeout = TimeSpan.FromSeconds(5);
switch (notEqualFieldName)
{
case "ConnectionMode": connectionMode = ConnectionMode.ReplicaSet; break;
case "ConnectTimeout": connectTimeout = TimeSpan.FromSeconds(99); break;
case "Credentials": credentials = new[] { MongoCredential.CreateMongoCRCredential("different", "different", "different") }; break;
case "IPv6": ipv6 = !ipv6; break;
case "LocalThreshold": localThreshold = TimeSpan.FromMilliseconds(99); break;
case "MaxConnectionIdleTime": maxConnectionIdleTime = TimeSpan.FromSeconds(99); break;
case "MaxConnectionLifeTime": maxConnectionLifeTime = TimeSpan.FromSeconds(99); break;
case "MaxConnectionPoolSize": maxConnectionPoolSize = 99; break;
case "MinConnectionPoolSize": minConnectionPoolSize = 99; break;
case "ReplicaSetName": replicaSetName = "different"; break;
case "Servers": servers = new[] { new MongoServerAddress("different") }; break;
case "ServerSelectionTimeout": serverSelectionTimeout = TimeSpan.FromSeconds(98); break;
case "SocketTimeout": socketTimeout = TimeSpan.FromSeconds(99); break;
case "SslSettings": sslSettings.CheckCertificateRevocation = !sslSettings.CheckCertificateRevocation; break;
case "UseSsl": useSsl = !useSsl; break;
case "VerifySslCertificate": verifySslCertificate = !verifySslCertificate; break;
case "WaitQueueSize": waitQueueSize = 99; break;
case "WaitQueueTimeout": waitQueueTimeout = TimeSpan.FromSeconds(99); break;
}
var clientSettings = new MongoClientSettings
{
ConnectionMode = connectionMode,
ConnectTimeout = connectTimeout,
Credentials = credentials,
GuidRepresentation = guidRepresentation,
IPv6 = ipv6,
MaxConnectionIdleTime = maxConnectionIdleTime,
MaxConnectionLifeTime = maxConnectionLifeTime,
MaxConnectionPoolSize = maxConnectionPoolSize,
MinConnectionPoolSize = minConnectionPoolSize,
ReplicaSetName = replicaSetName,
LocalThreshold = localThreshold,
Servers = servers,
ServerSelectionTimeout = serverSelectionTimeout,
SocketTimeout = socketTimeout,
SslSettings = sslSettings,
UseSsl = useSsl,
VerifySslCertificate = verifySslCertificate,
WaitQueueSize = waitQueueSize,
WaitQueueTimeout = waitQueueTimeout
};
return clientSettings.ToClusterKey();
}
public void TestDefaults()
{
var settings = new SslSettings();
Assert.Equal(true, settings.CheckCertificateRevocation);
Assert.Equal(null, settings.ClientCertificates);
Assert.Equal(null, settings.ClientCertificateSelectionCallback);
#if NETSTANDARD1_6
#pragma warning disable 618
Assert.Equal(SslProtocols.Tls | SslProtocols.Ssl3, settings.EnabledSslProtocols);
#pragma warning restore
#else
Assert.Equal(SslProtocols.Default, settings.EnabledSslProtocols);
#endif
Assert.Equal(null, settings.ServerCertificateValidationCallback);
}
public void ToClusterKey_should_copy_relevant_values()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Ssl3
};
var subject = new MongoClientSettings
{
ConnectionMode = ConnectionMode.Direct,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
LocalThreshold = TimeSpan.FromMilliseconds(20),
Servers = servers,
ServerSelectionTimeout = TimeSpan.FromSeconds(6),
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var result = subject.ToClusterKey();
result.ConnectionMode.Should().Be(subject.ConnectionMode);
result.ConnectTimeout.Should().Be(subject.ConnectTimeout);
result.Credentials.Should().Equal(subject.Credentials);
result.IPv6.Should().Be(subject.IPv6);
result.MaxConnectionIdleTime.Should().Be(subject.MaxConnectionIdleTime);
result.MaxConnectionLifeTime.Should().Be(subject.MaxConnectionLifeTime);
result.MaxConnectionPoolSize.Should().Be(subject.MaxConnectionPoolSize);
result.MinConnectionPoolSize.Should().Be(subject.MinConnectionPoolSize);
result.ReplicaSetName.Should().Be(subject.ReplicaSetName);
result.LocalThreshold.Should().Be(subject.LocalThreshold);
result.Servers.Should().Equal(subject.Servers);
result.ServerSelectionTimeout.Should().Be(subject.ServerSelectionTimeout);
result.SocketTimeout.Should().Be(subject.SocketTimeout);
result.SslSettings.Should().Be(subject.SslSettings);
result.UseSsl.Should().Be(subject.UseSsl);
result.VerifySslCertificate.Should().Be(subject.VerifySslCertificate);
result.WaitQueueSize.Should().Be(subject.WaitQueueSize);
result.WaitQueueTimeout.Should().Be(subject.WaitQueueTimeout);
}
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 TestEquals()
{
var settings = new SslSettings();
var clone = settings.Clone();
Assert.AreEqual(settings, clone);
clone = settings.Clone();
clone.CheckCertificateRevocation = !settings.CheckCertificateRevocation;
Assert.AreNotEqual(settings, clone);
clone = settings.Clone();
clone.ClientCertificates = new[] { new X509Certificate2("testcert.pfx", "password") };
Assert.AreNotEqual(settings, clone);
clone = settings.Clone();
clone.ClientCertificateSelectionCallback = ClientCertificateSelectionCallback;
Assert.AreNotEqual(settings, clone);
clone = settings.Clone();
clone.EnabledSslProtocols = SslProtocols.Tls;
Assert.AreNotEqual(settings, clone);
clone = settings.Clone();
clone.ServerCertificateValidationCallback = ServerCertificateValidationCallback;
Assert.AreNotEqual(settings, clone);
}
public void TestServerCertificateValidationCallback()
{
var settings = new SslSettings();
Assert.AreEqual(null, settings.ServerCertificateValidationCallback);
var callback = (RemoteCertificateValidationCallback)ServerCertificateValidationCallback;
settings.ServerCertificateValidationCallback = callback;
Assert.AreEqual(callback, settings.ServerCertificateValidationCallback);
settings.Freeze();
Assert.AreEqual(callback, settings.ServerCertificateValidationCallback);
Assert.Throws<InvalidOperationException>(() => { settings.ServerCertificateValidationCallback = callback; });
}
public void TestClone()
{
var settings = new SslSettings
{
CheckCertificateRevocation = false,
ClientCertificates = new[] { new X509Certificate2("testcert.pfx", "password") },
ClientCertificateSelectionCallback = ClientCertificateSelectionCallback,
EnabledSslProtocols = SslProtocols.Tls,
ServerCertificateValidationCallback = ServerCertificateValidationCallback
};
var clone = settings.Clone();
Assert.AreEqual(settings, clone);
}
private SslSettings GetSslSettings()
{
SslSettings sslSettings = null;
if (!string.IsNullOrEmpty(CertificateFriendlyName))
{
X509Certificate2 certificate = GetCertificate(CertificateFriendlyName);
if (null != certificate)
{
sslSettings = new SslSettings();
sslSettings.ClientCertificates = new List<X509Certificate2>() { certificate };
}
}
return sslSettings;
}
public void TestEnabledSslProtocols()
{
var settings = new SslSettings();
#if NETSTANDARD1_6
#pragma warning disable 618
Assert.Equal(SslProtocols.Tls | SslProtocols.Ssl3, settings.EnabledSslProtocols);
#pragma warning restore
#else
Assert.Equal(SslProtocols.Default, settings.EnabledSslProtocols);
#endif
var enabledSslProtocols = SslProtocols.Tls;
settings.EnabledSslProtocols = enabledSslProtocols;
Assert.Equal(enabledSslProtocols, settings.EnabledSslProtocols);
settings.Freeze();
Assert.Equal(enabledSslProtocols, settings.EnabledSslProtocols);
Assert.Throws<InvalidOperationException>(() => { settings.EnabledSslProtocols = enabledSslProtocols; });
}
public void TestDefaults()
{
var settings = new SslSettings();
Assert.AreEqual(true, settings.CheckCertificateRevocation);
Assert.AreEqual(null, settings.ClientCertificates);
Assert.AreEqual(null, settings.ClientCertificateSelectionCallback);
Assert.AreEqual(SslProtocols.Default, settings.EnabledSslProtocols);
Assert.AreEqual(null, settings.ServerCertificateValidationCallback);
}
