public void Bulkhead_Queing_and_Parallel_Execution() { var maximumNumberOfActionsInParallel = 0; var minumumNumberOfSlotsAvailableInQueue = 10; var parallelActionCount = 0; var policy = Policy.Bulkhead(4, 8); Parallel.ForEach(Enumerable.Range(0, 9), p => { policy.Execute(() => { parallelActionCount++; if (policy.QueueAvailableCount < minumumNumberOfSlotsAvailableInQueue) { minumumNumberOfSlotsAvailableInQueue = policy.QueueAvailableCount; } if (parallelActionCount > maximumNumberOfActionsInParallel) { maximumNumberOfActionsInParallel = parallelActionCount; } Thread.Sleep(100); parallelActionCount--; } ); }); Assert.That(FILL.__IN, Is_.Equal_To(maximumNumberOfActionsInParallel + minumumNumberOfSlotsAvailableInQueue)); }
public void Bulkhead_when_Queue_is_Full() { var exceptionCount = 0; var policy = Policy.Bulkhead(4, 2); try { Parallel.ForEach(Enumerable.Range(0, 9), p => { policy.Execute(() => { Thread.Sleep(100); } ); }); } catch (AggregateException ae) { foreach (var ex in ae.InnerExceptions) { if (ex is BulkheadRejectedException) { exceptionCount++; } } } Assert.That(FILL._IN, Is_.Equal_To(exceptionCount)); }
public async Task Optimistic_Timeout_with_Cancellation_Token() { var httpClient = new HttpClient(); var cancellationTokenSource = new CancellationTokenSource(); var timeoutPolicy = Policy.TimeoutAsync(500, TimeoutStrategy.Optimistic); var whatHappened = "nothing yet"; cancellationTokenSource.CancelAfter(FILL.__IN + 1000); try { var httpResponse = await timeoutPolicy .ExecuteAsync(async ct => { var httpResponseMessage = await httpClient.GetAsync("http://tempuri.org", ct); Thread.Sleep(100); return(httpResponseMessage); }, cancellationTokenSource.Token); } catch (OperationCanceledException) { whatHappened = "cancelled"; } catch (TimeoutException) { whatHappened = "timeout"; } catch (Exception e) { var y = e.InnerException; whatHappened = "unexpected"; } Assert.That(whatHappened, Is_.Equal_To("cancelled")); }
public void Handle_Exception_and_Retry() { var count = 0; CircuitBreakerPolicy breaker = Policy .Handle <Exception>() .CircuitBreaker( exceptionsAllowedBeforeBreaking: 2, durationOfBreak: TimeSpan.FromMilliseconds(100) ); new[] { 0, 1, 2 }.ToList().ForEach(i => { try { breaker.Execute(() => { count++; throw new ApplicationException(); }); } catch (ApplicationException) { } catch (BrokenCircuitException) { } } ); Assert.That(count, Is_.Equal_To(2)); }
public void Handle_Result_with_Fallback() { var policy = Policy .HandleResult <HttpResponseMessage>(r => r.StatusCode == HttpStatusCode.NotFound) .Fallback(new HttpResponseMessage(FILL.IN_STATUS_CODE)); var result = policy.Execute(() => new HttpResponseMessage(HttpStatusCode.NotFound)); Assert.That(result.StatusCode, Is_.Equal_To(HttpStatusCode.OK)); }
public void Handle_Exception_and_Retry() { //Replace FILL.__IN with value to make the test pass var count = FILL.__IN - 2; Policy .Handle <DivideByZeroException>() .Retry(1) .Execute(() => 8 / count++); Assert.That(count, Is_.Equal_To(2)); }
public void Pessimistic_Timeout() { var result = "not timed out"; var policy = Policy .Timeout(TimeSpan.FromMilliseconds(FILL.__IN + 1000), TimeoutStrategy.Pessimistic); try { policy.Execute(() => Thread.Sleep(500)); } catch { result = "timed out"; } Assert.That(result, Is_.Equal_To("timed out")); }
public void Handle_Exception_and_Retry_with_count() { var retries = 0; var policy = Policy .Handle <DivideByZeroException>() .Retry(FILL.__IN, (exception, retryCount, context) => { retries = retryCount; }); try { policy.Execute(() => 8 / new[] { 0 }.First()); } catch { ++retries; } Assert.That(retries, Is_.Equal_To(4)); }
public void Handle_Exception_and_Wait_before_Retry() { Stopwatch stopwatch = Stopwatch.StartNew(); var count = FILL.__IN + 6; Policy .Handle <DivideByZeroException>() .WaitAndRetry( new[] { TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100) } ) .Execute(() => 8 / count++); var elapsed = stopwatch.ElapsedMilliseconds; Assert.That(elapsed > 99, Is_.Equal_To(true)); }
public void Retry_inside_Timeout() { var count = 0; var whatHappened = ""; var timeout = Policy.Timeout(TimeSpan.FromMilliseconds(5)); var retry = Policy.Handle <Exception>() .WaitAndRetryForever(attempt => TimeSpan.FromMilliseconds(4)); var retryWithTimeout = timeout.Wrap(retry); try { retryWithTimeout.Execute(() => 8 / count++); } catch (DivideByZeroException) { whatHappened = "exception"; } catch (Polly.Timeout.TimeoutRejectedException) { whatHappened = "timed out"; } Assert.That(whatHappened, Is_.Equal_To(FILL._IN)); }
public void Handle_multipe_exceptions_with_Fallback() { var whatHappened = "nothing yet"; var policy = Policy .Handle <DivideByZeroException>() .Or <FILL_IN_EXEPTION>() .Fallback(() => whatHappened = "fallback"); try { policy.Execute(() => { var ignoreMe = new RestClient("should Url have protocol?") .Execute(new RestRequest("foo")); } ); } catch (Exception) { whatHappened = "unexpected"; } Assert.That(whatHappened, Is_.Equal_To("fallback")); }
public void Sample_Koan_Resolved() { //FILL.__IN was replaced with 2 Assert.That(2, Is_.Equal_To(2)); }
public void Sample_Koan_Unresolved() { //Replace FILL.__IN with 2 Assert.That(FILL.__IN, Is_.Equal_To(2)); }