public void Should_SendRequest_When_AConnectionIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var mockRequest = Mock.Of <IRequest>();
var mockRequestExecution = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockRequestExecution)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
Mock.Get(mockRequestExecution)
.Setup(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost);
var sut = new ProxyRequestExecution(mockRequestExecution, mockSession, mockRequest);
sut.Start(currentHostRetry);
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection)
.Verify(
c => c.Send(mockRequest, It.IsAny <Action <Exception, Response> >(), It.IsAny <int>()),
Times.Once);
});
}
public void Should_SendRequest_When_AConnectionIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>();
Mock.Get(requestHandlerFactory)
.Setup(r => r.Create(
It.IsAny <IInternalSession>(),
It.IsAny <ISerializer>(),
It.IsAny <IRequest>(),
It.IsAny <IStatement>(),
It.IsAny <IRequestOptions>()))
.Returns(Mock.Of <IRequestHandler>());
var config = new TestConfigurationBuilder
{
RequestHandlerFactory = requestHandlerFactory
}.Build();
Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config);
var mockRequest = Mock.Of <IRequest>();
var mockParent = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockParent)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
Mock.Get(mockParent)
.Setup(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost);
Mock.Get(mockParent)
.Setup(m => m.RequestOptions)
.Returns(config.DefaultRequestOptions);
var sut = new RequestExecution(mockParent, mockSession, mockRequest, NullRequestObserver.Instance);
sut.Start(currentHostRetry);
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection)
.Verify(
c => c.Send(mockRequest, It.IsAny <Action <IRequestError, Response> >(), It.IsAny <int>()),
Times.Once);
});
}
public async Task Pool_Increasing_Size_And_Closing_Should_Not_Leave_Connections_Open([Range(0, 29)] int delay)
{
_mock = GetPoolMock(null, GetConfig(50, 50));
_mock.Setup(p => p.DoCreateAndOpen(It.IsAny <bool>())).Returns(async() =>
{
await Task.Yield();
var spinWait = new SpinWait();
spinWait.SpinOnce();
return(await Task.Run(() => CreateConnection()).ConfigureAwait(false));
});
var pool = _mock.Object;
Assert.AreEqual(0, pool.OpenConnections);
pool.SetDistance(HostDistance.Local);
await pool.EnsureCreate().ConfigureAwait(false);
Assert.Greater(pool.OpenConnections, 0);
// Wait for the pool to be gaining size
TestHelper.RetryAssert(() =>
{
Assert.Greater(pool.OpenConnections, 1);
},
20,
100);
await Task.Run(() =>
{
pool.Dispose();
}).ConfigureAwait(false);
TestHelper.RetryAssert(() =>
{
Assert.AreEqual(0, pool.OpenConnections);
},
20,
100);
}
public void Should_RetryRequestToSameHost_When_ConnectionFailsAndRetryDecisionIsRetrySameHost()
{
var mockSession = Mock.Of <IInternalSession>();
var config = new Configuration();
Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config);
var mockRequest = Mock.Of <IRequest>();
var mockParent = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
// Setup hosts
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
var secondHost = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.2"), 9047),
new ConstantReconnectionPolicy(1)); // second host should never be used if test passes
var secondValidHost = ValidHost.New(
secondHost,
HostDistance.Local);
// Setup query plan
Mock.Get(mockParent)
.SetupSequence(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost)
.Returns(secondValidHost);
// Setup retry policy
var exception = new OverloadedException(string.Empty);
Mock.Get(mockParent)
.SetupGet(m => m.RetryPolicy)
.Returns(() =>
Mock.Of <IExtendedRetryPolicy>(a =>
a.OnRequestError(
It.IsAny <IStatement>(), config, exception, 0)
== RetryDecision.Retry(null, true)));
// Setup connection failure
Mock.Get(mockParent)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ThrowsAsync(exception);
// Setup successful second connection on the same host retry (different method call - ValidateHostAndGetConnectionAsync)
Mock.Get(mockParent)
.Setup(m => m.ValidateHostAndGetConnectionAsync(validHost.Host, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
var sut = new ProxyRequestExecution(mockParent, mockSession, mockRequest);
sut.Start(false);
// Validate request is sent
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection).Verify(
c => c.Send(mockRequest, It.IsAny <Action <Exception, Response> >(), It.IsAny <int>()),
Times.Once);
});
// Validate that there were 2 connection attempts (1 with each method)
Mock.Get(mockParent).Verify(
m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()),
Times.Once);
Mock.Get(mockParent).Verify(
m => m.ValidateHostAndGetConnectionAsync(validHost.Host, It.IsAny <Dictionary <IPEndPoint, Exception> >()),
Times.Once);
}
