public async Task should_call_action_on_every_exception_async() { ILog logger = A.Fake <ILog>(); await Retry.ExecuteAsync(() => AddOneAsync(3), TimeSpan.FromMilliseconds(100), 9, logger.WarnAsync); A.CallTo(() => logger.WarnAsync(A <Exception> .That.Matches(x => x.GetType() == typeof(NotSupportedException)))).MustHaveHappened(Repeated.Exactly.Times(2)); }
public async Task should_execute_once_and_then_retry_once_async_and_return() { int returnValue = await Retry.ExecuteAsync(async() => await AddOneTimeAsync(2), TimeSpan.FromMilliseconds(100), 1); returnValue.Should().Be(1); _timesCalled.Should().Be(2); }
public async Task RetryAsyncWithReturn() { // Execute the DoWorkAsync int i = await Retry.ExecuteAsync(async() => { return(await DummyMethods.DoWorkAsyncAndReturn()); }, TimeSpan.FromMilliseconds(100), 2); }
public async Task RetryAsync() { // Execute the DoWorkAsync await Retry.ExecuteAsync(async() => { await DummyMethods.DoWorkAsync(); }, TimeSpan.FromMilliseconds(100), 2); }
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var intervals = intervalsFactory(); return(await Retry.ExecuteAsync( async ct => await base.SendAsync(request, ct).ConfigureAwait(false), intervals, cancellationToken) .ConfigureAwait(false)); }
public async Task <CoapMessage> PostAsync(CoapMessage message) { try { CoapUri uri = new CoapUri(message.ResourceUri.ToString()); ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable; EventMetadata metadata = await GraphManager.GetPiSystemMetadataAsync(uri.Resource); if (!await adapter.CanPublishAsync(metadata, channel.IsEncrypted)) { if (metadata.Audit) { await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements")); } return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token)); } string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream"; EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit); if (!string.IsNullOrEmpty(uri.CacheKey)) { msg.CacheKey = uri.CacheKey; } if (uri.Indexes == null) { await adapter.PublishAsync(msg); } else { List <KeyValuePair <string, string> > indexes = new List <KeyValuePair <string, string> >(uri.Indexes); Task task = Retry.ExecuteAsync(async() => { await adapter.PublishAsync(msg, indexes); }); task.LogExceptions(); } return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token)); } catch (Exception ex) { Trace.TraceError("{0} - CoAP publish error on channel '{1}'", DateTime.UtcNow.ToString("yyyy-MM-ddTHH-MM-ss.fffff"), channel.Id); throw ex; } }
public async Task should_only_catch_given_exceptions_async() { bool success = false; try { await Retry.ExecuteAsync(() => AddOneAsync(100), TimeSpan.FromMilliseconds(1), 10, null, null, typeof(DivideByZeroException)); } catch (Exception exception) { exception.Should().BeOfType <NotSupportedException>(); success = true; } success.Should().BeTrue(); }
public async Task should_call_action_on_final_exception_async() { bool succes = false; ILog logger = A.Fake <ILog>(); try { await Retry.ExecuteAsync(() => AddOneAsync(10), TimeSpan.FromMilliseconds(100), 3, null, logger.ErrorAsync); } catch (Exception exception) { exception.Should().BeOfType <AggregateException>(); A.CallTo(() => logger.ErrorAsync(A <Exception> .That.Matches(x => x.GetType() == typeof(AggregateException)))).MustHaveHappened(Repeated.Exactly.Times(1)); succes = true; } succes.Should().BeTrue(); }
public async Task RetryAsyncWithAllFeatures() { // Execute the DoWorkAsync await Retry.ExecuteAsync(async() => await DummyMethods.DoWorkAsync(), TimeSpan.FromMilliseconds(100), 2, DummyMethods.ExecuteOnExceptionAsync, DummyMethods.ExecuteOnExceptionAsync, typeof(ArgumentException)); }
public async Task should_execute_once_and_then_retry_once_async_without_async_specification() { Action action = async() => { await AddOneAsync(2); }; await Retry.ExecuteAsync(action, TimeSpan.FromMilliseconds(100), 1); }
public async Task should_execute_once_and_then_retry_once_async() { int count = await Retry.ExecuteAsync(async() => await AddOneAsync(2), TimeSpan.FromMilliseconds(100), 1); count.Should().Be(2); }