Beispiel #1
0
        public void ShouldNotRetryOnSuccess()
        {
            var retryLogic = new RxRetryLogic(TimeSpan.FromSeconds(5), null);

            retryLogic
            .Retry(Observable.Return(5))
            .WaitForCompletion()
            .AssertEqual(
                OnNext(0, 5),
                OnCompleted <int>(0));
        }
Beispiel #2
0
        public void ShouldRetryOnTransientErrors(Exception error)
        {
            var retryLogic = new RxRetryLogic(TimeSpan.FromSeconds(5), null);

            retryLogic
            .Retry(CreateFailingObservable(1, error))
            .WaitForCompletion()
            .AssertEqual(
                OnNext(0, 1),
                OnCompleted <int>(0));
        }
Beispiel #3
0
        public void ShouldRetryAtLeastTwice()
        {
            var error      = new TransientException("code", "message");
            var logger     = new Mock <ILogger>();
            var retryLogic = new RxRetryLogic(TimeSpan.FromSeconds(1), logger.Object);

            retryLogic
            .Retry(CreateFailingObservable(TimeSpan.FromSeconds(2), 1, error))
            .WaitForCompletion()
            .AssertEqual(
                OnNext(0, 1),
                OnCompleted <int>(0));

            logger.Verify(x => x.Warn(error,
                                      It.Is <string>(s => s.StartsWith("Transaction failed and will be retried in"))),
                          Times.Once);
        }
Beispiel #4
0
        public void ShouldLogRetries(int errorCount)
        {
            var error      = new TransientException("code", "message");
            var logger     = new Mock <ILogger>();
            var retryLogic = new RxRetryLogic(TimeSpan.FromMinutes(1), logger.Object);

            retryLogic
            .Retry(CreateFailingObservable(1,
                                           Enumerable.Range(1, errorCount).Select(x => error).Cast <Exception>().ToArray()))
            .WaitForCompletion()
            .AssertEqual(
                OnNext(0, 1),
                OnCompleted <int>(0));

            logger.Verify(x => x.Warn(error,
                                      It.Is <string>(s => s.StartsWith("Transaction failed and will be retried in"))),
                          Times.Exactly(errorCount));
        }
Beispiel #5
0
        public void ShouldThrowServiceUnavailableWhenRetriesTimedOut()
        {
            var errorCount = 3;
            var exceptions = Enumerable.Range(1, errorCount).Select(i => new TransientException($"{i}", $"{i}"))
                             .Cast <Exception>().ToArray();
            var logger     = new Mock <ILogger>();
            var retryLogic = new RxRetryLogic(TimeSpan.FromSeconds(2), logger.Object);

            retryLogic
            .Retry(CreateFailingObservable(TimeSpan.FromSeconds(1), 1, exceptions))
            .WaitForCompletion()
            .AssertEqual(
                OnError <int>(0,
                              e => Matches(() =>
                                           e.Should().BeOfType <ServiceUnavailableException>()
                                           .Which.InnerException.Should().BeOfType <AggregateException>()
                                           .Which.InnerExceptions.Should().BeSubsetOf(exceptions))));
        }
Beispiel #6
0
        public void ShouldNotRetryOnNonTransientErrors(Exception error)
        {
            var retryLogic = new RxRetryLogic(TimeSpan.FromSeconds(5), null);

            var observable =
                Scheduler.CreateColdObservable(
                    OnNext(100, 1),
                    OnNext(150, 2),
                    OnNext(250, 3),
                    OnError <int>(350, error));

            var observer = Scheduler.Start(() =>
                                           retryLogic.Retry(observable), 0, 100, 500);

            observer.Messages.AssertEqual(
                OnNext(200, 1),
                OnNext(250, 2),
                OnNext(350, 3),
                OnError <int>(450, error));
        }