public async Task AddFailureUponCrossingThreadholdShouldCallOpenCircuitOrchestrator()
        {
            Mock <IDurableClient> clientMock = new Mock <IDurableClient>();

            clientMock.Setup(service => service.StartNewAsync("OpenCircuit", It.IsAny <FailureRequest>())).Returns(Task.FromResult(string.Empty)).Verifiable();

            CircuitBreakerActor function = new CircuitBreakerActor(clientMock.Object, this.logger);
            FailureRequest      req      = new FailureRequest
            {
                RequestId   = "RequestId",
                FailureTime = DateTime.UtcNow,
                InstanceId  = "InstanceId",
                ResourceId  = "ResourceID",
            };

            for (int i = 1; i <= 2; i++)
            {
                req.RequestId   = $"Req{i}";
                req.FailureTime = req.FailureTime.AddSeconds(10);
                await function.AddFailure(req).ConfigureAwait(false);
            }

            string expectedLogText = "Break this circuit for entity";

            Assert.Contains(expectedLogText, this.logger.Logs[1], StringComparison.OrdinalIgnoreCase);

            Mock.Verify();
        }
        public void VeirfyOpenCircuitState()
        {
            CircuitBreakerActor function = new CircuitBreakerActor(this.durableClientMock.Object, this.logger);

            function.OpenCircuit();

            Assert.Equal(CircuitState.Open, function.State);
        }
        public async Task AddFailureThrowExceptionWhenFailureRequestIsNull()
        {
            CircuitBreakerActor function = new CircuitBreakerActor(this.durableClientMock.Object, this.logger);

            Func <Task> testCode = async() => await function.AddFailure(null).ConfigureAwait(false);

            var ex = await Record.ExceptionAsync(testCode).ConfigureAwait(false);

            Assert.NotNull(ex);
            Assert.IsType <ArgumentNullException>(ex);
        }
        public async Task AddFailureShouldCountIncomingEvents1()
        {
            this.durableClientMock.Setup(service => service.StartNewAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(string.Empty));

            CircuitBreakerActor function = new CircuitBreakerActor(this.durableClientMock.Object, this.logger);
            FailureRequest      req      = new FailureRequest
            {
                RequestId   = "RequestId",
                FailureTime = DateTime.UtcNow,
                InstanceId  = "InstanceId",
                ResourceId  = "ResourceID",
            };

            req.RequestId = "Req1";
            await function.AddFailure(req).ConfigureAwait(false);

            string expectedLogText = "currently has 1 exceptions in the window";

            Assert.Contains(expectedLogText, this.logger.Logs[0], StringComparison.OrdinalIgnoreCase);
        }
        public async Task ShouldGenerateWarningLogIfCircuitIsAlreadyOpen()
        {
            this.durableClientMock.Setup(service => service.StartNewAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(string.Empty));

            CircuitBreakerActor function = new CircuitBreakerActor(this.durableClientMock.Object, this.logger);
            FailureRequest      req      = new FailureRequest
            {
                RequestId   = "RequestId",
                FailureTime = DateTime.UtcNow,
                InstanceId  = "InstanceId",
                ResourceId  = "ResourceID",
            };

            for (int i = 1; i <= 3; i++)
            {
                req.RequestId   = $"Req{i}";
                req.FailureTime = req.FailureTime.AddSeconds(10);
                await function.AddFailure(req).ConfigureAwait(false);
            }

            string expectedLogText = "Tried to add additional failure to";

            Assert.Contains(expectedLogText, this.logger.Logs[3], StringComparison.OrdinalIgnoreCase);
        }