public async Task TwoResponses_ErrorOnFirstGet_ReturnsError()
        {
            // Arrange
            var expected = new object();

            const int    payload2 = 5000;
            const string payload3 = "test-2";
            const string message1 = "test-error-1";
            const string message2 = "test-error-2";

            var results = new List <object>();

            var response1 = ResponseStub <decimal> .Error(message1);

            var response2 = ResponseStub <int> .Success(payload2);

            var transformed1 = ResponseStub <string> .Success(payload3);

            var errorResponse2 = ResponseStub <string> .Error(message2);

            var responseComposer = GetMock <IResponseComposer>();

            responseComposer.Setup(x => x.From <decimal, string>(response1)).Returns(errorResponse2);
            responseComposer.Setup(x => x.Success(payload3)).Returns(transformed1);

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(errorResponse2)).Returns(expected);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response1))
                         .Get(r =>
            {
                results.Add(r);
                return(Task.FromResult(response2));
            })
                         .Combine((p, r) =>
            {
                results.Add(p);
                results.Add(r);
                return(payload3);
            })
                         .EvaluateAsync(page, responseComposer);

            // Assert
            result.Should().Be(expected);
            results.Should().BeEmpty();

            logger.Trace.Should().BeEmpty();
            logger.Error.Should()
            .Contain(response1)
            .And.HaveCount(1);
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #2
0
        public async Task SingleResponse_TryAfterTransform_ReturnsResult()
        {
            // Arrange
            const decimal payload     = 1000m;
            const string  transformed = "test";

            var response = GetMock <IResponse <decimal> >();

            response.Setup(x => x.Succeeded).Returns(true);
            response.Setup(x => x.Payload).Returns(payload);

            var results = new List <object>();

            var expected = new object();

            var responseComposer = GetMock <IResponseComposer>();

            var positiveTry         = ResponseStub.Success();
            var transformedResponse = ResponseStub <string> .Success(transformed);

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(transformedResponse)).Returns(expected);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response))
                         .Transform(r =>
            {
                results.Add(r.Payload);
                return(Task.FromResult(transformedResponse));
            })
                         .Try(r =>
            {
                results.Add(r);
                return(Task.FromResult(positiveTry));
            })
                         .EvaluateAsync(page, responseComposer, null, null);

            // Assert
            result.Should().Be(expected);
            results.Should().Contain(payload).And.Contain(transformed).And.HaveCount(2);

            logger.Trace.Should()
            .Contain(response)
            .And.Contain(positiveTry)
            .And.Contain(transformedResponse)
            .And.HaveCount(3);
            logger.Error.Should().BeEmpty();
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #3
0
        public async Task SingleResponse_WithFailedTry_ReturnsResult()
        {
            // Arrange
            const decimal payload = 1000m;

            var response = GetMock <IResponse <decimal> >();

            response.Setup(x => x.Succeeded).Returns(true);
            response.Setup(x => x.Payload).Returns(payload);

            var results = new List <object>();

            var expected = new object();

            const string expectedError = "E";
            var          negativeTry   = ResponseStub.Error(expectedError);

            var errorResult = ResponseStub <decimal> .Error("E2");

            var responseComposer = GetMock <IResponseComposer>();

            responseComposer
            .Setup(x => x.From <decimal>(negativeTry))
            .Returns(errorResult);

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(errorResult)).Returns(expected);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response))
                         .Try(r =>
            {
                results.Add(r);
                return(Task.FromResult(negativeTry));
            })
                         .EvaluateAsync(page, responseComposer, null, null);

            // Assert
            result.Should().Be(expected);
            results.Should().Contain(payload).And.HaveCount(1);
            logger.Trace.Should().Contain(response).And.HaveCount(1);
            logger.Error.Should().Contain(negativeTry)
            .And.HaveCount(1);
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #4
0
        public async Task TwoResponses_WithCustomHandler_ReturnsResult()
        {
            // Arrange
            const decimal payload1 = 1000m;
            const string  payload2 = "test";

            var results = new List <object>();

            var response = GetMock <IResponse <decimal> >();

            response.Setup(x => x.Succeeded).Returns(true);
            response.Setup(x => x.Payload).Returns(payload1);

            var responseComposer = GetMock <IResponseComposer>();

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(response)).Returns(new object());

            var response2 = ResponseStub <string> .Success(payload2);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response))
                         .Get(t =>
            {
                results.Add(t);
                return(Task.FromResult(response2));
            })
                         .Evaluate(page, responseComposer, ((value, p) =>
            {
                results.Add(value);
                return(p);
            }), null);

            // Assert
            result.Should().Be(page);
            results.Should().Contain(payload1).And.Contain(payload2).And.HaveCount(2);

            logger.Trace.Should().Contain(response).And.Contain(response2).And.HaveCount(2);
            logger.Error.Should().BeEmpty();
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #5
0
        public async Task TwoResponses_ReturnsResult()
        {
            // Arrange
            var results  = new List <object>();
            var response = ResponseStub <object> .Success(new object());

            var expected = new object();

            var responseComposer = GetMock <IResponseComposer>();

            const decimal payload1 = 1000m;

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(response)).Returns(expected);

            var response1 = ResponseStub <decimal> .Success(payload1);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() =>
            {
                return(Task.FromResult(response1));
            })
                         .Get(t =>
            {
                results.Add(t);
                return(Task.FromResult(response));
            })
                         .EvaluateAsync(page, responseComposer, null, null);

            // Assert
            results.Should().Contain(payload1).And.HaveCount(1);
            result.Should().Be(expected);

            logger.Trace.Should()
            .Contain(response)
            .And.Contain(response1)
            .And.HaveCount(2);
            logger.Error.Should().BeEmpty();
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #6
0
        public async Task SingleResponse_WithTransform_WithCustomHandler_ReturnsResult()
        {
            // Arrange
            const string expectedError = "error";
            var          response      = ResponseStub <decimal> .Error(expectedError);

            var responseComposer = GetMock <IResponseComposer>();

            const string expected    = "expected";
            var          transformed = new ResponseStub <string>()
            {
                Succeeded = true, Payload = expected
            };

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);
            page.Setup(x => x.Return(response)).Returns(new object());

            string receivedValue = null;

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response))
                         .Transform(r => Task.FromResult((IResponse <string>)transformed))
                         .Evaluate(page, responseComposer, ((value, p) =>
            {
                receivedValue = value;
                return(p);
            }), null);

            // Assert
            result.Should().Be(page);
            receivedValue.Should().Be(expected);

            logger.Error.Should().Contain(x => x is IResponse <decimal> && !((IResponse <decimal>)x).Succeeded && ((IResponse <decimal>)x).Message == expectedError).And.HaveCount(1);
            logger.Trace.Should().Contain(transformed).And.HaveCount(1);
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }
Пример #7
0
        public async Task TwoResponses_WithTransform_WithCustomHandler_ReturnsResult()
        {
            // Arrange
            const string payload2 = "test";
            const bool   payload3 = true;

            var results = new List <object>();

            const string payload1 = "expected";

            const decimal payload0 = 1000m;

            var responseComposer = GetMock <IResponseComposer>();

            var response1 = ResponseStub <decimal> .Success(payload0);

            var response2 = ResponseStub <string> .Success(payload2);

            var transformed1 = ResponseStub <string> .Success(payload1);

            var transformed2 = ResponseStub <bool> .Success(payload3);

            var logger = new LoggerStub();
            var page   = GetMock <IPageModelBase <object> >();

            page.Setup(x => x.Logger).Returns(logger);

            // Act
            var result = await ResponsePipeline <object>
                         .Get(() => Task.FromResult(response1))
                         .Transform(r =>
            {
                results.Add(r);
                return(Task.FromResult(transformed1));
            })
                         .Get(r =>
            {
                results.Add(r);
                return(Task.FromResult(response2));
            })
                         .Transform((p, r) =>
            {
                results.Add(p);
                results.Add(r);
                return(Task.FromResult(transformed2));
            })
                         .Evaluate(page, responseComposer, ((value, p) =>
            {
                results.Add(value);
                return(p);
            }), null);

            // Assert
            result.Should().Be(page);

            results[0].Should().Be(response1);
            results[1].Should().Be(payload1);
            results[2].Should().BeAssignableTo <IResponse <string> >().And.Match(x => (x as IResponse <string>).Payload == payload1);
            results[3].Should().BeAssignableTo <IResponse <string> >().And.Match(x => (x as IResponse <string>).Payload == payload2);
            results[4].Should().Be(payload3);
            results.Should().HaveCount(5);

            logger.Trace.Should()
            .Contain(response1)
            .And.Contain(response2)
            .And.Contain(transformed1)
            .And.Contain(transformed2)
            .And.HaveCount(4);
            logger.Error.Should().BeEmpty();
            logger.Debug.Should().BeEmpty();
            logger.Information.Should().BeEmpty();
            logger.Warning.Should().BeEmpty();
            logger.Critical.Should().BeEmpty();
        }