public async Task Retry_OneMessageHasBeenReadTransientExceptionOccured_Throws()
{
int callCounter = 0;
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var memoryStream = new NotSeekableStream(new byte[] { 1, 2, 3 });
var message = new Message(memoryStream);
var messages = new[] { message };
innerHandlerMock.SendEventAsync(Arg.Is(messages), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
Message m = t.Arg <IEnumerable <Message> >().First();
Stream stream = m.GetBodyStream();
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
throw new IotHubClientTransientException("");
});
var sut = new RetryDelegatingHandler(innerHandlerMock);
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(messages, cancellationToken).ExpectedAsync <IotHubClientTransientException>();
Assert.AreEqual(callCounter, 1);
}
public async Task DeviceNotFoundExceptionReturnsDeviceDisabledStatus()
{
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t => throw new DeviceNotFoundException());
ConnectionStatus? status = null;
ConnectionStatusChangeReason? statusChangeReason = null;
ConnectionStatusChangesHandler statusChangeHandler = (s, r) =>
{
status = s;
statusChangeReason = r;
};
contextMock.Get <ConnectionStatusChangesHandler>().Returns(statusChangeHandler);
var cancellationToken = new CancellationToken();
var testee = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await((Func <Task>)(() => testee.OpenAsync(cancellationToken))).ExpectedAsync <DeviceNotFoundException>().ConfigureAwait(false);
Assert.AreEqual(ConnectionStatus.Disconnected, status);
Assert.AreEqual(ConnectionStatusChangeReason.Device_Disabled, statusChangeReason);
}
private void PostInit(string baseUri, RestClient restClient)
{
this._restClient = restClient;
if (baseUri == null)
{
throw new ArgumentNullException("baseUri");
}
if (restClient.Credentials == null)
{
throw new ArgumentNullException("credentials");
}
BaseUri = new Uri(baseUri);
Credentials = restClient.Credentials;
if (Credentials != null)
{
Credentials.InitializeServiceClient(this);
}
// Set RetryPolicy
RetryDelegatingHandler delegatingHandler = this.HttpMessageHandlers.OfType <RetryDelegatingHandler>().FirstOrDefault();
if (delegatingHandler != null && this._restClient.RetryPolicy != null &&
delegatingHandler.RetryPolicy != this._restClient.RetryPolicy)
{
delegatingHandler.RetryPolicy = this._restClient.RetryPolicy;
}
}
public async Task HttpClientTimeoutReturnsErrorResponse(string content)
{
// Setup the RetryDelegatingHandler to retry very quickly.
var retryStrategy = new FixedIntervalRetryStrategy(Int32.MaxValue, TimeSpan.FromTicks(1));
var retryPolicy = new RetryPolicy(new HttpStatusCodeErrorDetectionStrategy(), retryStrategy);
var fakeHttpHandler = new FakeHttpHandler
{
TweakResponse = (response) =>
{
response.Content = content == null ? null : new StringContent(String.Empty);
}
};
var retryHandler = new RetryDelegatingHandler(retryPolicy, fakeHttpHandler);
// Setup HttpClient to timeout after 500 milliseconds.
var httpClient = new HttpClient(retryHandler, false)
{
Timeout = TimeSpan.FromMilliseconds(500)
};
// Make a request using the HttpClient.
var fakeClient = new FakeServiceClient(httpClient);
var responseMessage = fakeClient.DoStuffSync();
Assert.NotNull(responseMessage);
Assert.True(fakeHttpHandler.NumberOfTimesFailedSoFar > 1);
Assert.Equal(HttpStatusCode.InternalServerError, responseMessage.StatusCode);
}
public async Task OpenAsyncInnerFailedSutIsOpenAndCanBeReopen()
{
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
bool shouldThrow = true;
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(ci =>
{
if (shouldThrow)
{
throw new IOException();
}
else
{
return(TaskHelpers.CompletedTask);;
}
});
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
var cancellationToken = new CancellationToken();
await sut.OpenAsync(cancellationToken).ExpectedAsync <IOException>().ConfigureAwait(false);
shouldThrow = false;
await sut.OpenAsync(cancellationToken).ConfigureAwait(false);
}
public async Task Retry_MessageHasBeenReadTransientExceptionOccured_Throws()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var memoryStream = new NotSeekableStream(new byte[] { 1, 2, 3 });
var message = new Message(memoryStream);
innerHandlerMock.SendEventAsync(Arg.Is(message), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
var m = t.Arg <Message>();
Stream stream = m.GetBodyStream();
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
throw new IotHubClientTransientException("");
});
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(message, cancellationToken).ExpectedAsync <IotHubClientTransientException>();
Assert.AreEqual(callCounter, 1);
}
public async Task Retry_NonTransientErrorThrown_Throws()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(true, Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
if (callCounter == 1)
{
throw new InvalidOperationException("");
}
return(TaskConstants.Completed);
});
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var cancellationToken = new CancellationToken();
await sut.OpenAsync(true, cancellationToken).ExpectedAsync <InvalidOperationException>();
Assert.AreEqual(callCounter, 1);
}
public async Task Retry_TransientErrorOccured_Retried()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(true, Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
if (callCounter == 1)
{
throw new IotHubClientTransientException("");
}
return(TaskConstants.Completed);
});
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var cancellationToken = new CancellationToken();
await sut.OpenAsync(true, cancellationToken);
Assert.AreEqual(2, callCounter);
}
public async Task RetryMessageWithSeekableStreamHasBeenReadTransientExceptionOccuredThrows()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var message = new Message(new MemoryStream(new byte[] { 1, 2, 3 }));
innerHandlerMock.SendEventAsync(Arg.Is(message), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
var m = t.Arg <Message>();
Stream stream = m.GetBodyStream();
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
if (callCounter == 1)
{
throw new IotHubClientTransientException("");
}
return(TaskConstants.Completed);
});
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(message, cancellationToken).ConfigureAwait(false);
Assert.AreEqual(callCounter, 2);
}
public async Task Retry_OneMessageHasBeenTouchedTransientExceptionOccured_Success()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var message = new Message(new MemoryStream(new byte[] { 1, 2, 3 }));
IEnumerable <Message> messages = new[] { message };
innerHandlerMock.SendEventAsync(Arg.Is(messages), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
Message m = t.Arg <IEnumerable <Message> >().First();
Stream stream = m.GetBodyStream();
if (callCounter == 1)
{
throw new IotHubClientTransientException("");
}
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
return(TaskConstants.Completed);
});
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(messages, cancellationToken);
Assert.AreEqual(2, callCounter);
}
// Creates a single HttpMessageHandler to construct a HttpClient with from a base httpMessageHandler and some number of custom delegating handlers
// This is almost a copy of the Microsoft.Rest.ClientRuntime library's implementation, but with the return and parameter type HttpClientHandler replaced
// with the more abstract HttpMessageHandler in order for us to set the base handler as either a SocketsHttpHandler for .net core or an HttpClientHandler otherwise
// https://github.com/Azure/azure-sdk-for-net/blob/99f4da88ab0aa01c79aa291c6c101ab94c4ac940/sdk/mgmtcommon/ClientRuntime/ClientRuntime/ServiceClient.cs#L376
private static HttpMessageHandler CreateHttpHandlerPipeline(HttpMessageHandler httpMessageHandler, params DelegatingHandler[] handlers)
{
// The RetryAfterDelegatingHandler should be the absolute outermost handler
// because it's extremely lightweight and non-interfering
HttpMessageHandler currentHandler =
#pragma warning disable CA2000 // Dispose objects before losing scope (delegating handler is disposed when the http client that uses it is disposed)
new RetryDelegatingHandler(new RetryAfterDelegatingHandler {
InnerHandler = httpMessageHandler
});
#pragma warning restore CA2000 // Dispose objects before losing scope
if (handlers != null)
{
for (int i = handlers.Length - 1; i >= 0; --i)
{
DelegatingHandler handler = handlers[i];
// Non-delegating handlers are ignored since we always
// have RetryDelegatingHandler as the outer-most handler
while (handler.InnerHandler is DelegatingHandler)
{
handler = handler.InnerHandler as DelegatingHandler;
}
handler.InnerHandler = currentHandler;
currentHandler = handlers[i];
}
}
return(currentHandler);
}
private DelegatingHandler CreateHttpHandlerPipeline(HttpClientHandler httpClientHandler, params DelegatingHandler[] handlers)
{
// Now, the RetryAfterDelegatingHandler should be the absolute outermost handler
// because it's extremely lightweight and non-interfering
DelegatingHandler currentHandler =
#pragma warning disable CA2000 // Dispose objects before losing scope (suppressing this warning, for now! we will address this once we implement HttpClientFactory in a future release)
new RetryDelegatingHandler(new RetryAfterDelegatingHandler {
InnerHandler = httpClientHandler
});
#pragma warning restore CA2000 // Dispose objects before losing scope
if (handlers != null)
{
for (var i = handlers.Length - 1; i >= 0; --i)
{
var handler = handlers[i];
// Non-delegating handlers are ignored since we always
// have RetryDelegatingHandler as the outer-most handler
while (handler.InnerHandler is DelegatingHandler)
{
handler = handler.InnerHandler as DelegatingHandler;
}
handler.InnerHandler = currentHandler;
currentHandler = handlers[i];
}
}
return(currentHandler);
}
public async Task Retry_MessageHasBeenTouchedTransientExceptionOccured_Success()
{
int callCounter = 0;
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var message = new Message(new MemoryStream(new byte[] { 1, 2, 3 }));
innerHandlerMock.SendEventAsync(Arg.Is(message), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
var m = t.Arg <Message>();
Stream stream = m.GetBodyStream();
if (callCounter == 1)
{
throw new IotHubClientTransientException("");
}
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
return(TaskConstants.Completed);
});
var sut = new RetryDelegatingHandler(innerHandlerMock);
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(message, cancellationToken);
Assert.AreEqual(2, callCounter);
}
private void InitializeHttpClient(HttpClientHandler httpClientHandler, params DelegatingHandler[] handlers)
{
this.HttpClientHandler = httpClientHandler;
DelegatingHandler currentHandler = new RetryDelegatingHandler();
currentHandler.InnerHandler = this.HttpClientHandler;
if (handlers != null)
{
for (int i = handlers.Length - 1; i >= 0; --i)
{
DelegatingHandler handler = handlers[i];
// Non-delegating handlers are ignored since we always
// have RetryDelegatingHandler as the outer-most handler
while (handler.InnerHandler is DelegatingHandler)
{
handler = handler.InnerHandler as DelegatingHandler;
}
handler.InnerHandler = currentHandler;
currentHandler = handlers[i];
}
}
var newClient = new HttpClient(currentHandler, false);
this.FirstMessageHandler = currentHandler;
this.HttpClient = newClient;
Type type = this.GetType();
this.HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(
type.FullName,
this.GetAssemblyVersion()));
}
public void Retry_SetRetryPolicyVerifyInternals_Success()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var contextMock = Substitute.For <IPipelineContext>();
var sut = new RetryDelegatingHandler(contextMock);
sut.ContinuationFactory = c => innerHandlerMock;
var exponentialBackoff = new ExponentialBackoff(10, TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(10));
sut.SetRetryPolicy(exponentialBackoff);
Assert.AreEqual(typeof(RetryDelegatingHandler.IotHubTransientErrorIgnoreStrategy), sut.internalRetryPolicy.ErrorDetectionStrategy.GetType());
Assert.AreEqual(typeof(RetryDelegatingHandler.IotHubRuntimeOperationRetryStrategy), sut.internalRetryPolicy.RetryStrategy.GetType());
var iotHubRuntimeOperationRetryStrategy = (RetryDelegatingHandler.IotHubRuntimeOperationRetryStrategy)sut.internalRetryPolicy.RetryStrategy;
Assert.AreEqual(typeof(TransientFaultHandling.RetryStrategyWrapper), iotHubRuntimeOperationRetryStrategy.retryStrategy.GetType());
Assert.AreSame(exponentialBackoff, ((TransientFaultHandling.RetryStrategyWrapper)iotHubRuntimeOperationRetryStrategy.retryStrategy).retryPolicy);
var noretry = new NoRetry();
sut.SetRetryPolicy(noretry);
Assert.AreEqual(typeof(RetryDelegatingHandler.IotHubTransientErrorIgnoreStrategy), sut.internalRetryPolicy.ErrorDetectionStrategy.GetType());
Assert.AreEqual(typeof(RetryDelegatingHandler.IotHubRuntimeOperationRetryStrategy), sut.internalRetryPolicy.RetryStrategy.GetType());
iotHubRuntimeOperationRetryStrategy = (RetryDelegatingHandler.IotHubRuntimeOperationRetryStrategy)sut.internalRetryPolicy.RetryStrategy;
Assert.AreEqual(typeof(TransientFaultHandling.RetryStrategyWrapper), iotHubRuntimeOperationRetryStrategy.retryStrategy.GetType());
Assert.AreSame(noretry, ((TransientFaultHandling.RetryStrategyWrapper)iotHubRuntimeOperationRetryStrategy.retryStrategy).retryPolicy);
}
private DelegatingHandler CreateHttpHandlerPipeline(HttpClientHandler httpClientHandler, params DelegatingHandler[] handlers)
{
// Now, the RetryAfterDelegatingHandler should be the absolute outermost handler
// because it's extremely lightweight and non-interfering
DelegatingHandler currentHandler =
new RetryDelegatingHandler(new RetryAfterDelegatingHandler {
InnerHandler = httpClientHandler
});
if (handlers != null)
{
for (var i = handlers.Length - 1; i >= 0; --i)
{
var handler = handlers[i];
// Non-delegating handlers are ignored since we always
// have RetryDelegatingHandler as the outer-most handler
while (handler.InnerHandler is DelegatingHandler)
{
handler = handler.InnerHandler as DelegatingHandler;
}
handler.InnerHandler = currentHandler;
currentHandler = handlers[i];
}
}
return(currentHandler);
}
public async Task RetryTransientErrorOccuredRetried()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
if (callCounter == 1)
{
throw new IotHubException("Test transient exception", isTransient: true);
}
return(Task.CompletedTask);
});
innerHandlerMock.WaitForTransportClosedAsync().Returns(Task.Delay(TimeSpan.FromSeconds(10)));
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
var cancellationToken = new CancellationToken();
await sut.OpenAsync(cancellationToken).ConfigureAwait(false);
Assert.AreEqual(2, callCounter);
}
public async Task Retry_NonSeekableStream_NotSupportedException()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var memoryStream = new NotSeekableStream(new byte[] { 1, 2, 3 });
var message = new Message(memoryStream);
innerHandlerMock.SendEventAsync(Arg.Is(message), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
var m = t.Arg <Message>();
Stream stream = m.GetBodyStream();
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
throw new IotHubException(TestExceptionMessage, isTransient: true);
});
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
var cancellationToken = new CancellationToken();
NotSupportedException exception = await sut.SendEventAsync(message, cancellationToken).ExpectedAsync <NotSupportedException>().ConfigureAwait(false);
Assert.AreEqual(callCounter, 1);
}
public async Task RetrySetRetryPolicyVerifyInternalsSuccess()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var contextMock = Substitute.For <IPipelineContext>();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
var retryPolicy = new TestRetryPolicy();
sut.SetRetryPolicy(retryPolicy);
int innerHandlerCallCounter = 0;
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t =>
{
innerHandlerCallCounter++;
return(Task.FromException(new IotHubCommunicationException()));
});
await sut.OpenAsync(CancellationToken.None).ExpectedAsync <IotHubCommunicationException>().ConfigureAwait(false);
Assert.AreEqual(2, innerHandlerCallCounter);
Assert.AreEqual(2, retryPolicy.Counter);
var noretry = new NoRetry();
sut.SetRetryPolicy(noretry);
await sut.OpenAsync(CancellationToken.None).ExpectedAsync <IotHubCommunicationException>().ConfigureAwait(false);
Assert.AreEqual(3, innerHandlerCallCounter);
Assert.AreEqual(2, retryPolicy.Counter);
}
public async Task RetryMessageHasBeenTouchedTransientExceptionOccuredSuccess()
{
int callCounter = 0;
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var message = new Message(new MemoryStream(new byte[] { 1, 2, 3 }));
innerHandlerMock.SendEventAsync(Arg.Is(message), Arg.Any <CancellationToken>()).Returns(t =>
{
callCounter++;
var m = t.Arg <Message>();
Stream stream = m.GetBodyStream();
if (callCounter == 1)
{
throw new IotHubException(TestExceptionMessage, isTransient: true);
}
var buffer = new byte[3];
stream.Read(buffer, 0, 3);
return(Task.CompletedTask);
});
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
var cancellationToken = new CancellationToken();
await sut.SendEventAsync(message, cancellationToken).ConfigureAwait(false);
Assert.AreEqual(2, callCounter);
}
public async Task Retry_CloseAsyncBeforeOpen_Ok()
{
var contextMock = Substitute.For <PipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.CloseAsync(CancellationToken.None).Returns(t => TaskHelpers.CompletedTask);
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await sut.CloseAsync(CancellationToken.None).ConfigureAwait(false);
}
public async Task Retry_CancellationTokenCanceled_Receive()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
innerHandlerMock.ReceiveAsync(cancellationTokenSource.Token).Returns(new Task <Message>(() => new Message(new byte[0])));
var sut = new RetryDelegatingHandler(innerHandlerMock);
await sut.ReceiveAsync(cancellationTokenSource.Token).ExpectedAsync <TaskCanceledException>();
}
public async Task OpenAsyncInnerCompletedSubjIsOpen()
{
var contextMock = Substitute.For <IPipelineContext>();
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t => Task.CompletedTask);
var cancellationToken = new CancellationToken();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await sut.OpenAsync(cancellationToken).ConfigureAwait(false);
}
public async Task Retry_CancellationTokenCanceled_Reject()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.RejectAsync(Arg.Any <string>(), Arg.Any <CancellationToken>()).Returns(TaskConstants.Completed);
var sut = new RetryDelegatingHandler(innerHandlerMock);
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
await sut.RejectAsync(Arg.Any <string>(), cancellationTokenSource.Token).ExpectedAsync <TaskCanceledException>();
}
public async Task RetryCancellationTokenCanceledReceive()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
innerHandlerMock.ReceiveAsync(cancellationTokenSource.Token).Returns(new Task <Message>(() => new Message(new byte[0])));
var contextMock = Substitute.For <IPipelineContext>();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await sut.ReceiveAsync(cancellationTokenSource.Token).ExpectedAsync <TaskCanceledException>().ConfigureAwait(false);
}
public async Task Retry_TransientErrorThrownAfterNumberOfRetries_Throws()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(Arg.Is(true)).Returns(t =>
{
throw new IotHubClientTransientException("");
});
var sut = new RetryDelegatingHandler(innerHandlerMock);
await sut.OpenAsync(true).ExpectedAsync <IotHubClientTransientException>();
}
public async Task OpenAsyncInnerCompletedSubjIsOpen()
{
var contextMock = Substitute.For <PipelineContext>();
contextMock.ConnectionStatusChangesHandler = new ConnectionStatusChangesHandler(delegate(ConnectionStatus status, ConnectionStatusChangeReason reason) { });
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t => TaskHelpers.CompletedTask);
var cancellationToken = new CancellationToken();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await sut.OpenAsync(cancellationToken).ConfigureAwait(false);
}
public void InstantiateRetryDelegatingHandler()
{
RetryDelegatingHandler retryHandler = new RetryDelegatingHandler();
FakeServiceClient fakeClient = new FakeServiceClient(new FakeHttpHandler(), retryHandler);
var handlers = fakeClient.HttpMessageHandlers;
if (handlers.Any <HttpMessageHandler>())
{
List <HttpMessageHandler> handlerList = handlers.ToList <HttpMessageHandler>();
Assert.Equal(4, handlerList.Count);
}
}
public async Task RetryCancellationTokenCanceledReject()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
innerHandlerMock.RejectAsync(null, CancellationToken.None).ReturnsForAnyArgs(TaskHelpers.CompletedTask);
var contextMock = Substitute.For <IPipelineContext>();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
using var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
await sut.RejectAsync(Arg.Any <string>(), cancellationTokenSource.Token).ExpectedAsync <TaskCanceledException>().ConfigureAwait(false);
}
public async Task RetryCancellationTokenCanceledOpen()
{
var innerHandlerMock = Substitute.For <IDelegatingHandler>();
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(TaskHelpers.CompletedTask);
var contextMock = Substitute.For <IPipelineContext>();
var sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
await sut.OpenAsync(cancellationTokenSource.Token).ExpectedAsync <TaskCanceledException>().ConfigureAwait(false);
}
