public void Should_ThrowException_When_NoValidHosts(bool currentHostRetry) { var mockSession = Mock.Of <IInternalSession>(); var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>(); Mock.Get(requestHandlerFactory) .Setup(r => r.Create( It.IsAny <IInternalSession>(), It.IsAny <Serializer>(), It.IsAny <IRequest>(), It.IsAny <IStatement>())) .Returns(Mock.Of <IRequestHandler>()); var config = new TestConfigurationBuilder { RequestHandlerFactory = requestHandlerFactory }.Build(); Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config); Mock.Get(mockSession).SetupGet(m => m.Configuration).Returns(config); var mockRequest = Mock.Of <IRequest>(); var mockRequestExecution = Mock.Of <IRequestHandler>(); Mock.Get(mockRequestExecution) .Setup(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >())) .Throws(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>())); var sut = new RequestExecution(mockRequestExecution, mockSession, mockRequest); Assert.Throws <NoHostAvailableException>(() => sut.Start(currentHostRetry)); }
public void DowngradingConsistencyRetryTest() { var config = new Configuration(); var policy = DowngradingConsistencyRetryPolicy.Instance.Wrap(null); var dummyStatement = new SimpleStatement().SetRetryPolicy(policy); //Retry if 1 of 2 replicas are alive var decision = RequestExecution.GetRetryDecision( new UnavailableException(ConsistencyLevel.Two, 2, 1), policy, dummyStatement, config, 0); Assert.True(decision != null && decision.DecisionType == RetryDecision.RetryDecisionType.Retry); //Retry if 2 of 3 replicas are alive decision = RequestExecution.GetRetryDecision( new UnavailableException(ConsistencyLevel.Three, 3, 2), policy, dummyStatement, config, 0); Assert.True(decision != null && decision.DecisionType == RetryDecision.RetryDecisionType.Retry); //Throw if 0 replicas are alive decision = RequestExecution.GetRetryDecision( new UnavailableException(ConsistencyLevel.Three, 3, 0), policy, dummyStatement, config, 0); Assert.True(decision != null && decision.DecisionType == RetryDecision.RetryDecisionType.Rethrow); //Retry if 1 of 3 replicas is alive decision = RequestExecution.GetRetryDecision(new ReadTimeoutException(ConsistencyLevel.All, 3, 1, false), policy, dummyStatement, config, 0); Assert.True(decision != null && decision.DecisionType == RetryDecision.RetryDecisionType.Retry); }
public void RequestExecution_GetRetryDecision_Test() { var policy = Policies.DefaultRetryPolicy; var statement = new SimpleStatement("SELECT WILL FAIL"); //Using default retry policy the decision will always be to rethrow on read/write timeout var expected = RetryDecision.RetryDecisionType.Rethrow; var decision = RequestExecution <RowSet> .GetRetryDecision(new ReadTimeoutException(ConsistencyLevel.Quorum, 1, 2, true), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); decision = RequestExecution <RowSet> .GetRetryDecision(new WriteTimeoutException(ConsistencyLevel.Quorum, 1, 2, "SIMPLE"), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); decision = RequestExecution <RowSet> .GetRetryDecision(new UnavailableException(ConsistencyLevel.Quorum, 2, 1), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); decision = RequestExecution <RowSet> .GetRetryDecision(new Exception(), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); //Expecting to retry when a Cassandra node is Bootstrapping/overloaded expected = RetryDecision.RetryDecisionType.Retry; decision = RequestExecution <RowSet> .GetRetryDecision(new OverloadedException(null), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); decision = RequestExecution <RowSet> .GetRetryDecision(new IsBootstrappingException(null), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); decision = RequestExecution <RowSet> .GetRetryDecision(new TruncateException(null), policy, statement, 0); Assert.AreEqual(expected, decision.DecisionType); }
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 void Should_NotThrowException_When_AValidHostIsObtained(bool currentHostRetry) { var mockSession = Mock.Of <IInternalSession>(); var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>(); Mock.Get(requestHandlerFactory) .Setup(r => r.Create( It.IsAny <IInternalSession>(), It.IsAny <Serializer>(), It.IsAny <IRequest>(), It.IsAny <IStatement>())) .Returns(Mock.Of <IRequestHandler>()); var config = new TestConfigurationBuilder { RequestHandlerFactory = requestHandlerFactory }.Build(); Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config); Mock.Get(mockSession).SetupGet(m => m.Configuration).Returns(config); var mockRequest = Mock.Of <IRequest>(); var mockRequestExecution = Mock.Of <IRequestHandler>(); 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) .SetupSequence(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >())) .Returns(validHost) .Throws(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>())); var sut = new RequestExecution(mockRequestExecution, mockSession, mockRequest); sut.Start(currentHostRetry); }
public void Should_RetryRequestToSameHost_When_ConnectionFailsAndRetryDecisionIsRetrySameHost() { var mockSession = Mock.Of <IInternalSession>(); var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>(); Mock.Get(requestHandlerFactory) .Setup(r => r.Create( It.IsAny <IInternalSession>(), It.IsAny <Serializer>(), It.IsAny <IRequest>(), It.IsAny <IStatement>())) .Returns(Mock.Of <IRequestHandler>()); var config = new TestConfigurationBuilder { RequestHandlerFactory = requestHandlerFactory }.Build(); Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config); Mock.Get(mockSession).SetupGet(m => m.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 RequestExecution(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); }
internal static RetryDecision GetRetryDecisionFromClientError(Exception ex, IExtendedRetryPolicy policy, IStatement statement, Configuration config, int retryCount) { return(RequestExecution.GetRetryDecisionWithReason(RequestError.CreateClientError(ex, false), policy, statement, config, retryCount).Decision); }