public void ShouldReleaseAll()
{
var mock = new Mock <IPooledConnection>();
mock.Setup(x => x.IsOpen).Returns(true);
var inUseConns = new ConcurrentSet <IPooledConnection>();
inUseConns.TryAdd(mock.Object);
var availableConns = new ConcurrentQueue <IPooledConnection>();
var mock1 = new Mock <IPooledConnection>();
mock1.Setup(x => x.IsOpen).Returns(true);
availableConns.Enqueue(mock1.Object);
var pool = new ConnectionPool(null, availableConns, inUseConns);
pool.NumberOfAvailableConnections.Should().Be(1);
pool.NumberOfInUseConnections.Should().Be(1);
pool.Dispose();
pool.NumberOfAvailableConnections.Should().Be(0);
pool.NumberOfInUseConnections.Should().Be(0);
}
public void ShouldLogInUseAndAvailableConnectionIds()
{
var mockLogger = new Mock <ILogger>();
var mock = new Mock <IPooledConnection>();
mock.Setup(x => x.IsOpen).Returns(true);
var inUseConns = new ConcurrentSet <IPooledConnection>();
inUseConns.TryAdd(mock.Object);
var availableConns = new ConcurrentQueue <IPooledConnection>();
var mock1 = new Mock <IPooledConnection>();
mock1.Setup(x => x.IsOpen).Returns(true);
availableConns.Enqueue(mock1.Object);
var pool = new ConnectionPool(null, availableConns, inUseConns, mockLogger.Object);
pool.Dispose();
mockLogger.Verify(x => x.Info(It.Is <string>(actual => actual.StartsWith("Disposing In Use"))),
Times.Once);
mockLogger.Verify(x => x.Debug(It.Is <string>(actual => actual.StartsWith("Disposing Available"))),
Times.Once);
}
public void ShouldReleaseAll()
{
var mock = new Mock <IPooledConnection>();
mock.Setup(x => x.IsHealthy).Returns(true);
var id = Guid.NewGuid();
var inUseConns = new Dictionary <Guid, IPooledConnection>();
inUseConns.Add(id, mock.Object);
var availableConns = new Queue <IPooledConnection>();
var mock1 = new Mock <IPooledConnection>();
mock1.Setup(x => x.IsHealthy).Returns(true);
availableConns.Enqueue(mock1.Object);
var pool = new ConnectionPool(null, availableConns, inUseConns);
pool.NumberOfAvailableConnections.Should().Be(1);
pool.NumberOfInUseConnections.Should().Be(1);
pool.Dispose();
pool.NumberOfAvailableConnections.Should().Be(0);
pool.NumberOfInUseConnections.Should().Be(0);
}
public void Close()
{
_cts.Cancel();
((SingleThreadScheduler)Factory.Scheduler).Dispose();
Close(ref _writeConnection);
_readerConnections?.Dispose();
Path = null;
}
public void ShouldNotThrowExceptionWhenDisposedTwice()
{
// Given
var mock = new Mock <IPooledConnection>();
var inUseConns = new ConcurrentSet <IPooledConnection>();
inUseConns.TryAdd(mock.Object);
var pool = new ConnectionPool(null, null, inUseConns);
// When
pool.Dispose();
pool.Dispose();
// Then
mock.Verify(x => x.Close(), Times.Once);
pool.NumberOfAvailableConnections.Should().Be(0);
pool.NumberOfInUseConnections.Should().Be(0);
}
public void Dispose()
{
pollingClients.Dispose();
pool.Dispose();
foreach (var listener in listeners)
{
listener.Dispose();
}
}
public void ShouldThrowExceptionWhenAcquireCalledAfterDispose()
{
var pool = new ConnectionPool(MockedConnection);
pool.Dispose();
var exception = Record.Exception(() => pool.Acquire());
exception.Should().BeOfType <ObjectDisposedException>();
exception.Message.Should().StartWith("Failed to acquire a new connection");
}
public void ShouldNotThrowExceptionWhenDisposedTwice()
{
// Given
var mock = new Mock <IPooledConnection>();
var id = Guid.NewGuid();
var inUseConns = new Dictionary <Guid, IPooledConnection> {
{ id, mock.Object }
};
var pool = new ConnectionPool(null, null, inUseConns);
// When
pool.Dispose();
pool.Dispose();
// Then
mock.Verify(x => x.Close(), Times.Once);
pool.NumberOfAvailableConnections.Should().Be(0);
pool.NumberOfInUseConnections.Should().Be(0);
}
public void ShouldThrowExceptionWhenAcquireCalledAfterDispose()
{
var pool = new ConnectionPool(MockedConnection);
pool.Dispose();
var exception = Record.Exception(() => pool.Acquire());
exception.Should().BeOfType <InvalidOperationException>();
exception.Message.Should().Contain("the driver has already been disposed");
}
public WhenDisposingAConnectionPoolWithActiveConnections()
{
_connection = new Mock <IConnection>();
_connectionFactory = new Mock <IConnectionCreator>();
_connectionFactory
.Setup(cf => cf.CreateOpenedAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_connection.Object);
_connectionPool = new ConnectionPool(_config, _connectionFactory.Object);
_connectionPool.GetConnectionAsync().Wait();
_connectionPool.Dispose();
}
public WhenReturningAnActiveConnectionToADisposedPool()
{
_connection = new Mock <IConnection>();
_connectionFactory = new Mock <IConnectionCreator>();
_connectionFactory
.Setup(cf => cf.CreateOpenedAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_connection.Object);
_connectionPool = new ConnectionPool(_config, _connectionFactory.Object);
var activeConnection = _connectionPool.GetConnectionAsync().Result;
_connectionPool.Dispose();
activeConnection.Dispose();
}
public void ShouldReturnDirectlyWhenConnectionReleaseCalledAfterPoolDispose()
{
// Given
var mock = new Mock <IPooledConnection>();
var inUseConns = new ConcurrentSet <IPooledConnection>();
inUseConns.TryAdd(mock.Object);
var pool = new ConnectionPool(null, null, inUseConns);
// When
pool.Dispose();
pool.Release(mock.Object);
// Then
mock.Verify(x => x.Close(), Times.Once);
}
public void ShouldReturnDirectlyWhenConnectionReleaseCalledAfterPoolDispose()
{
// Given
var mock = new Mock <IPooledConnection>();
var id = Guid.NewGuid();
var inUseConns = new Dictionary <Guid, IPooledConnection> {
{ id, mock.Object }
};
var pool = new ConnectionPool(null, null, inUseConns);
// When
pool.Dispose();
pool.Release(id);
// Then
mock.Verify(x => x.Close(), Times.Once);
}
public void Disposing_pool_does_not_affect_busy_sockets()
{
var sockets = new List <FakeDisposableSocket>();
Func <ISocket> socketFactory = () => {
var socket = new FakeDisposableSocket();
sockets.Add(socket);
return(socket);
};
var pool = new ConnectionPool(socketFactory);
var s1 = pool.GetSocket();
Assert.AreEqual(1, sockets.Count, "wrong number of sockets created");
Assert.IsFalse(sockets[0].Disposed, "socket was disposed");
pool.Dispose();
Assert.IsFalse(sockets[0].Disposed, "socket was disposed");
s1.Dispose();
}
public void Disposing_pool_cleans_up_sockets()
{
var sockets = new List <FakeDisposableSocket>();
Func <ISocket> socketFactory = () => {
var socket = new FakeDisposableSocket();
sockets.Add(socket);
return(socket);
};
var pool = new ConnectionPool(socketFactory);
var s1 = pool.GetSocket();
var s2 = pool.GetSocket();
s1.Dispose();
s2.Dispose();
Assert.AreEqual(2, sockets.Count, "wrong number of sockets created");
Assert.IsFalse(sockets[0].Disposed, "first socket was disposed");
Assert.IsFalse(sockets[1].Disposed, "second socket was disposed");
pool.Dispose();
Assert.IsTrue(sockets[0].Disposed, "first socket was not disposed");
Assert.IsTrue(sockets[1].Disposed, "second socket was not disposed");
}
public void Dispose()
{
Db.Multiplexer.GetSubscriber().UnsubscribeAll();
ConnectionPool.Dispose();
}
public void Dispose()
{
ConnectionPool.Dispose();
}
public void CheckIfPoolIsCleared()
{
_pool.Dispose();
Assert.IsTrue(_pool.Active.Count == 0);
}