private async Task <StepResult> HandleHttpResponseAsync(HttpWebRequest request, MessagingContext ctx)
        {
            Logger.Trace($"AS4Message received from: {request.Address}");
            (HttpWebResponse webResponse, WebException exception) =
                await _httpClient.Respond(request)
                .ConfigureAwait(false);

            if (webResponse != null &&
                ContentTypeSupporter.IsContentTypeSupported(webResponse.ContentType))
            {
                using (AS4Response res = await AS4Response.Create(ctx, webResponse).ConfigureAwait(false))
                {
                    SendResult result = SendResultUtils.DetermineSendResultFromHttpResonse(res.StatusCode);
                    await UpdateRetryStatusForMessageAsync(ctx, result);

                    var handler = new PullRequestResponseHandler(
                        _createDatastore,
                        new EmptyBodyResponseHandler(
                            new TailResponseHandler()));

                    return(await handler
                           .HandleResponse(res)
                           .ConfigureAwait(false));
                }
            }

            Logger.ErrorDeep(exception);
            throw new WebException($"Failed to Send AS4Message to Url: {request.RequestUri}.", exception);
        }
            public async Task ThenHandlerReturnsFixedValue()
            {
                // Arrange
                AS4Response expectedResponse = CreateAnonymousAS4Response();
                var         handler          = new TailResponseHandler();

                // Act
                StepResult actualResult = await handler.HandleResponse(expectedResponse);

                // Assert
                Assert.Equal(expectedResponse.ReceivedStream, actualResult.MessagingContext.ReceivedMessage);
                AssertNoChangeInPModes(expectedResponse, actualResult);
            }
            public async Task ThenNextHandlerGetsResponse_IfNotOriginatedFromPullRequest()
            {
                // Arrange
                AS4Response as4Response = CreateAnonymousAS4Response();

                var spyHandler = new SpyAS4ResponseHandler();
                var handler    = new PullRequestResponseHandler(() => null, spyHandler);

                // Act
                await handler.HandleResponse(as4Response);

                // Assert
                Assert.True(spyHandler.IsCalled);
            }
        private static AS4Response CreateAnonymousAS4Response()
        {
            var stubResponse = new Mock <HttpWebResponse>();

            stubResponse.Setup(r => r.ContentType)
            .Returns(Constants.ContentTypes.Soap);

            return(AS4Response.Create(
                       requestMessage: new EmptyMessagingContext
            {
                SendingPMode = new SendingProcessingMode(),
                ReceivingPMode = new ReceivingProcessingMode()
            },
                       webResponse: stubResponse.Object).Result);
        }
 private static AS4Response CreateAS4ResponseWith(HttpWebResponse webResponse = null, MessagingContext messageRequest = null)
 {
     return(AS4Response.Create(
                requestMessage: messageRequest,
                webResponse: webResponse).Result);
 }