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); }