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>();
mockConnectionHandle
.Setup(c => c.Open(It.IsAny <CancellationToken>()))
.Throws(new MongoAuthenticationException(connectionId, "Invalid login."));
mockConnectionHandle
.Setup(c => c.OpenAsync(It.IsAny <CancellationToken>()))
.Throws(new MongoAuthenticationException(connectionId, "Invalid login."));
var mockConnectionPool = new Mock <IConnectionPool>();
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());
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint))
.Returns(mockConnectionPool.Object);
var server = new Server(
_clusterId,
_clusterClock,
_clusterConnectionMode,
_connectionModeSwitch,
_directConnection,
_settings,
_endPoint,
mockConnectionPoolFactory.Object,
_mockServerMonitorFactory.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(), Times.Once());
}
public void GetChannel_should_throw_when_not_initialized(
[Values(false, true)]
bool async)
{
Action act;
if (async)
{
act = () => _subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act = () => _subject.GetChannel(CancellationToken.None);
}
act.ShouldThrow <InvalidOperationException>();
}
public void GetChannel_should_update_topology_and_clear_connection_pool_on_network_error_or_timeout(
[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 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());
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint))
.Returns(connectionPool);
var mockMonitorServerDescription = new ServerDescription(serverId, _endPoint);
var mockServerMonitor = new Mock <IServerMonitor>();
mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerDescription);
mockServerMonitor.SetupGet(m => m.Lock).Returns(new object());
var mockServerMonitorFactory = new Mock <IServerMonitorFactory>();
mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object);
var subject = new Server(_clusterId, _clusterClock, _clusterConnectionMode, _connectionModeSwitch, _directConnection, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.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.Unknown);
subject.Description.ReasonChanged.Should().Contain("ChannelException during handshake");
}
public void GetChannel_should_get_a_connection(
[Values(false, true)]
bool async)
{
_subject.Initialize();
IChannelHandle channel;
if (async)
{
channel = _subject.GetChannelAsync(CancellationToken.None).GetAwaiter().GetResult();
}
else
{
channel = _subject.GetChannel(CancellationToken.None);
}
channel.Should().NotBeNull();
}
public void GetChannel_should_update_topology_and_clear_connection_pool_on_network_error_or_timeout(
[Values("timedout", "networkunreachable")] string errorType,
[Values(false, true)] bool async)
{
var serverId = new ServerId(_clusterId, _endPoint);
var connectionId = new ConnectionId(serverId);
var innerMostException = CoreExceptionHelper.CreateSocketException(errorType);
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 mockConnectionPool = new Mock <IConnectionPool>();
mockConnectionPool.Setup(p => p.AcquireConnection(It.IsAny <CancellationToken>())).Returns(mockConnection.Object);
mockConnectionPool.Setup(p => p.AcquireConnectionAsync(It.IsAny <CancellationToken>())).ReturnsAsync(mockConnection.Object);
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(f => f.CreateConnectionPool(It.IsAny <ServerId>(), _endPoint))
.Returns(mockConnectionPool.Object);
var mockMonitorServerDescription = new ServerDescription(serverId, _endPoint);
var mockServerMonitor = new Mock <IServerMonitor>();
mockServerMonitor.SetupGet(m => m.Description).Returns(mockMonitorServerDescription);
mockServerMonitor
.Setup(m => m.Invalidate(It.IsAny <string>()))
.Callback((string reason) => MockMonitorInvalidate(reason));
var mockServerMonitorFactory = new Mock <IServerMonitorFactory>();
mockServerMonitorFactory.Setup(f => f.Create(It.IsAny <ServerId>(), _endPoint)).Returns(mockServerMonitor.Object);
var subject = new Server(_clusterId, _clusterClock, _clusterConnectionMode, _settings, _endPoint, mockConnectionPoolFactory.Object, mockServerMonitorFactory.Object, _capturedEvents);
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.Unknown);
subject.Description.ReasonChanged.Should().Contain("ChannelException during handshake");
mockServerMonitor.Verify(m => m.Invalidate(It.IsAny <string>()), Times.Once);
mockConnectionPool.Verify(p => p.Clear(), Times.Once);
void MockMonitorInvalidate(string reason)
{
var currentDescription = mockServerMonitor.Object.Description;
mockServerMonitor.SetupGet(m => m.Description).Returns(currentDescription.With(reason));
}
}
