public void GetChannel_should_clear_connection_pool_when_opening_connection_throws_MongoAuthenticationException( [Values(false, true)] bool async) { var connectionId = new ConnectionId(new ServerId(_clusterId, _endPoint)); var mockConnectionHandle = new Mock <IConnectionHandle>(); var mockConnectionExceptionHandler = new Mock <IConnectionExceptionHandler>(); LoadBalancedServer server = null; var mockConnectionPool = new Mock <IConnectionPool>(); var authenticationException = new MongoAuthenticationException(connectionId, "Invalid login.") { ServiceId = ObjectId.GenerateNewId() }; mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Callback(() => server.HandleExceptionOnOpen(authenticationException)) .Throws(authenticationException); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Callback(() => server.HandleExceptionOnOpen(authenticationException)) .Throws(authenticationException); mockConnectionPool.Setup(p => p.Clear(It.IsAny <ObjectId>())); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(mockConnectionPool.Object); server = new LoadBalancedServer( _clusterId, _clusterClock, _settings, _endPoint, mockConnectionPoolFactory.Object, _capturedEvents, _serverApi); server.Initialize(); var exception = Record.Exception(() => { if (async) { server.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult(); } else { server.GetChannel(CancellationToken.None); } }); exception.Should().BeOfType <MongoAuthenticationException>(); mockConnectionPool.Verify(p => p.Clear(It.IsAny <ObjectId>()), Times.Once()); }
public void GetChannel_should_not_update_topology_and_clear_connection_pool_on_MongoConnectionException( [Values("TimedOutSocketException", "NetworkUnreachableSocketException")] string errorType, [Values(false, true)] bool async) { var serverId = new ServerId(_clusterId, _endPoint); var connectionId = new ConnectionId(serverId); var innerMostException = CoreExceptionHelper.CreateException(errorType); var mockConnectionExceptionHandler = new Mock <IConnectionExceptionHandler>(); var openConnectionException = new MongoConnectionException(connectionId, "Oops", new IOException("Cry", innerMostException)); var mockConnection = new Mock <IConnectionHandle>(); mockConnection.Setup(c => c.Open(It.IsAny <CancellationToken>())).Throws(openConnectionException); mockConnection.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>())).ThrowsAsync(openConnectionException); var connectionFactory = new Mock <IConnectionFactory>(); connectionFactory.Setup(cf => cf.CreateConnection(serverId, _endPoint)).Returns(mockConnection.Object); var connectionPoolSettings = new ConnectionPoolSettings(); var connectionPool = new ExclusiveConnectionPool(serverId, _endPoint, connectionPoolSettings, connectionFactory.Object, new EventAggregator(), mockConnectionExceptionHandler.Object); var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(connectionPool); var subject = new LoadBalancedServer(_clusterId, _clusterClock, _settings, _endPoint, mockConnectionPoolFactory.Object, _capturedEvents, _serverApi); subject.Initialize(); IChannelHandle channel = null; Exception exception; if (async) { exception = Record.Exception(() => channel = subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult()); } else { exception = Record.Exception(() => channel = subject.GetChannel(CancellationToken.None)); } channel.Should().BeNull(); exception.Should().Be(openConnectionException); subject.Description.Type.Should().Be(ServerType.LoadBalanced); subject.Description.ReasonChanged.Should().Be("Initialized"); subject.Description.State.Should().Be(ServerState.Connected); _mockConnectionPool.Verify(c => c.Clear(It.IsAny <bool>()), Times.Never); }
public LoadBalancedTests() { _clusterId = new ClusterId(); _endPoint = new DnsEndPoint("localhost", 27017); _clusterClock = new Mock <IClusterClock>().Object; _mockConnectionPool = new Mock <IConnectionPool>(); _mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(new Mock <IConnectionHandle>().Object); _mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(new Mock <IConnectionHandle>().Object)); _mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); _mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint)) .Returns(_mockConnectionPool.Object); _capturedEvents = new EventCapturer(); _serverApi = new ServerApi(ServerApiVersion.V1, true, true); _settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan); _subject = new LoadBalancedServer(_clusterId, _clusterClock, _settings, _endPoint, _mockConnectionPoolFactory.Object, _capturedEvents, _serverApi); _connectionId = new ConnectionId(_subject.ServerId); }
public void Constructor_should_not_throw_when_serverApi_is_null() { _ = new LoadBalancedServer(_clusterId, _clusterClock, _settings, _endPoint, _mockConnectionPoolFactory.Object, _capturedEvents, serverApi: null); }
public static void HandleChannelException(this LoadBalancedServer server, IConnection connection, Exception ex) { Reflector.Invoke(server, nameof(HandleChannelException), connection, ex, checkBaseClass: true); }
// private methods private Server SetupServer(bool exceptionOnConnectionOpen, bool exceptionOnConnectionAcquire) { var connectionId = new ConnectionId(new ServerId(_clusterId, _endPoint)); var mockConnectionHandle = new Mock <IConnectionHandle>(); var mockConnectionExceptionHandler = new Mock <IConnectionExceptionHandler>(); mockConnectionHandle .Setup(c => c.Fork()) .Returns(mockConnectionHandle.Object); var mockConnectionPool = new Mock <IConnectionPool>(); if (exceptionOnConnectionAcquire) { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Throws(new TimeoutException("Timeout")); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Throws(new TimeoutException("Timeout")); mockConnectionPool.Setup(p => p.Clear(It.IsAny <bool>())); } else if (exceptionOnConnectionOpen) { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Throws(new MongoAuthenticationException(connectionId, "Invalid login.")); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Throws(new MongoAuthenticationException(connectionId, "Invalid login.")); mockConnectionPool.Setup(p => p.Clear(It.IsAny <bool>())); } else { mockConnectionPool .Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())) .Returns(mockConnectionHandle.Object); mockConnectionPool .Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(mockConnectionHandle.Object)); mockConnectionPool.Setup(p => p.Clear(It.IsAny <bool>())); } var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>(); mockConnectionPoolFactory .Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint, It.IsAny <IConnectionExceptionHandler>())) .Returns(mockConnectionPool.Object); var server = new LoadBalancedServer( _clusterId, _clusterClock, _settings, _endPoint, mockConnectionPoolFactory.Object, _capturedEvents, _serverApi); server.Initialize(); return(server); }