Пример #1
0
        public async Task ExecuteRequestMessagesAsync_DisposesResponseInCaseOfException()
        {
            List <MockHttpResponseMessage> responses = new List <MockHttpResponseMessage>();
            MockHttpServer server = new MockHttpServer(request =>
            {
                if (request.Method == HttpMethod.Put)
                {
                    throw new InvalidOperationException();
                }
                var response = new MockHttpResponseMessage();
                responses.Add(response);
                return(response);
            });
            DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(server);

            ODataBatchRequestItem[] requests = new ODataBatchRequestItem[]
            {
                new OperationRequestItem(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                new OperationRequestItem(new HttpRequestMessage(HttpMethod.Post, "http://example.com/")),
                new OperationRequestItem(new HttpRequestMessage(HttpMethod.Put, "http://example.com/")),
            };

            await ExceptionAssert.ThrowsAsync <InvalidOperationException>(
                () => batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None));

            Assert.Equal(2, responses.Count);
            foreach (var response in responses)
            {
                Assert.True(response.IsDisposed);
            }
        }
Пример #2
0
        public async Task SendRequestAsync_Throws_WhenRequestIsNull()
        {
            // Arrange
            Mock <RequestDelegate> handler = new Mock <RequestDelegate>();

            // Act & Assert
            await ExceptionAssert.ThrowsArgumentNullAsync(
                () => ODataBatchRequestItem.SendRequestAsync(handler.Object, null, null),
                "context");
        }
Пример #3
0
        public async Task SendRequestAsync_Throws_WhenInvokerIsNull()
        {
            // Arrange
            Mock <HttpContext> httpContext = new Mock <HttpContext>();

            // Act & Assert
            await ExceptionAssert.ThrowsArgumentNullAsync(
                () => ODataBatchRequestItem.SendRequestAsync(null, httpContext.Object, null),
                "handler");
        }
 private void fixRequestUri(ODataBatchRequestItem request)
 {
     foreach (HttpRequestMessage req in ((ChangeSetRequestItem)request).Requests)
     {
         var oldUri        = req.RequestUri;
         var newUriBuilder = new UriBuilder(oldUri);
         newUriBuilder.Path = "/odata" + newUriBuilder.Path;
         req.RequestUri     = newUriBuilder.Uri;
     }
 }
Пример #5
0
        public void SendMessageAsync_CallsInvoker()
        {
            HttpResponseMessage response = new HttpResponseMessage();

            HttpMessageInvoker invoker = new HttpMessageInvoker(new MockHttpServer((request) =>
            {
                return(response);
            }));

            var result = ODataBatchRequestItem.SendMessageAsync(invoker, new HttpRequestMessage(HttpMethod.Get, "http://example.com"), CancellationToken.None, new Dictionary <string, string>()).Result;

            Assert.Same(response, result);
        }
Пример #6
0
        public async Task SendRequestAsync_CallsHandler()
        {
            // Arrange
            HttpContext context = HttpContextHelper.Create("Get", "http://example.com");

            RequestDelegate handler = context =>
            {
                context.Response.StatusCode = StatusCodes.Status201Created;
                return(Task.FromResult(context.Response));
            };

            // Act
            await ODataBatchRequestItem.SendRequestAsync(handler, context, new Dictionary <string, string>());

            // Assert
            Assert.Equal(StatusCodes.Status201Created, context.Response.StatusCode);
        }
        public async Task ExecuteRequestMessagesAsync_CallsInvokerForEachRequest()
        {
            // Arrange
            RequestDelegate handler = async context =>
            {
                HttpRequest request         = context.Request;
                string      responseContent = request.GetDisplayUrl();
                string      content         = request.ReadBody();
                if (!string.IsNullOrEmpty(content))
                {
                    responseContent += "," + content;
                }

                context.Response.Body = new MemoryStream();
                await context.Response.WriteAsync(responseContent);
            };

            ODataBatchRequestItem[] requests = new ODataBatchRequestItem[]
            {
                new OperationRequestItem(HttpContextHelper.Create("Get", "http://example.com/")),
                new ChangeSetRequestItem(new HttpContext[]
                {
                    HttpContextHelper.Create("Post", "http://example.com/values", "foo", "text/plan")
                })
            };
            DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler();

            // Act
            IList <ODataBatchResponseItem> responses = await batchHandler.ExecuteRequestMessagesAsync(requests, handler);

            // Assert
            Assert.Equal(2, responses.Count);

            // #1
            OperationResponseItem response0 = Assert.IsType <OperationResponseItem>(responses[0]);

            Assert.Equal("http://example.com/", response0.Context.Response.ReadBody());

            // #2
            ChangeSetResponseItem response1  = Assert.IsType <ChangeSetResponseItem>(responses[1]);
            HttpContext           subContext = Assert.Single(response1.Contexts);

            Assert.Equal("http://example.com/values,foo", response1.Contexts.First().Response.ReadBody());
        }
Пример #8
0
        public async Task SendMessageAsync_Resolves_Uri_From_ContentId()
        {
            // Arrange
            DefaultHttpContext          context  = new DefaultHttpContext();
            HttpResponseMessage         response = new HttpResponseMessage();
            RequestDelegate             handler  = (c) => { return(Task.FromResult(response)); };
            Dictionary <string, string> contentIdLocationMappings = new Dictionary <string, string>();

            contentIdLocationMappings.Add("1", "http://localhost:12345/odata/Customers(42)");
            Uri unresolvedUri = new Uri("http://localhost:12345/odata/$1/Orders");

            context.Request.CopyAbsoluteUrl(unresolvedUri);

            // Act
            await ODataBatchRequestItem.SendRequestAsync(handler, context, contentIdLocationMappings);

            // Assert
            Assert.Equal("/odata/Customers(42)/Orders", context.Request.Path.ToString());
        }
Пример #9
0
        public async Task ExecuteRequestMessagesAsync_CallsInvokerForEachRequest()
        {
            MockHttpServer server = new MockHttpServer(async request =>
            {
                string responseContent = request.RequestUri.AbsoluteUri;
                if (request.Content != null)
                {
                    string content = await request.Content.ReadAsStringAsync();
                    if (!String.IsNullOrEmpty(content))
                    {
                        responseContent += "," + content;
                    }
                }
                return(new HttpResponseMessage {
                    Content = new StringContent(responseContent)
                });
            });
            DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(server);

            ODataBatchRequestItem[] requests = new ODataBatchRequestItem[]
            {
                new OperationRequestItem(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                new ChangeSetRequestItem(new HttpRequestMessage[]
                {
                    new HttpRequestMessage(HttpMethod.Post, "http://example.com/values")
                    {
                        Content = new StringContent("foo")
                    }
                })
            };

            var responses = await batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None);

            var response0 = (OperationResponseItem)responses[0];
            var response1 = (ChangeSetResponseItem)responses[1];

            Assert.Equal(2, responses.Count);
            Assert.Equal("http://example.com/", await response0.Response.Content.ReadAsStringAsync());
            Assert.Equal("http://example.com/values,foo", await response1.Responses.First().Content.ReadAsStringAsync());
        }
Пример #10
0
 public void SendMessageAsync_Throws_WhenRequestIsNull()
 {
     Assert.ThrowsArgumentNull(
         () => ODataBatchRequestItem.SendMessageAsync(new HttpMessageInvoker(new HttpServer()), null, CancellationToken.None, null).Wait(),
         "request");
 }
Пример #11
0
 public void SendMessageAsync_Throws_WhenInvokerIsNull()
 {
     Assert.ThrowsArgumentNull(
         () => ODataBatchRequestItem.SendMessageAsync(null, new HttpRequestMessage(), CancellationToken.None, null).Wait(),
         "invoker");
 }
Пример #12
0
        /// <summary>
        /// Asynchronously sends the request.
        /// </summary>
        /// <param name="handler">The handler for processing a message.</param>
        /// <returns>The task object that contains the batch response.</returns>
        public override async Task <ODataBatchResponseItem> SendRequestAsync(RequestDelegate handler)
        {
            Ensure.NotNull(handler, nameof(handler));

            var changeSetProperty = new RestierChangeSetProperty(this)
            {
                ChangeSet = new ChangeSet(),
            };

            SetChangeSetProperty(changeSetProperty);

            var contentIdToLocationMapping = new Dictionary <string, string>();
            var responseTasks = new List <Task <Task <HttpContext> > >();

            foreach (var context in this.Contexts)
            {
                // Since exceptions may occure before the request is sent to RestierController,
                // we must catch the exceptions here and call OnChangeSetCompleted,
                // so as to avoid deadlock mentioned in Github Issue #82.
                var tcs  = new TaskCompletionSource <HttpContext>();
                var task =
                    ODataBatchRequestItem.SendRequestAsync(handler, context, contentIdToLocationMapping)
                    .ContinueWith(
                        t =>
                {
                    if (t.Exception != null)
                    {
                        var taskEx = (t.Exception.InnerExceptions != null &&
                                      t.Exception.InnerExceptions.Count == 1)
                                        ? t.Exception.InnerExceptions.First()
                                        : t.Exception;
                        changeSetProperty.Exceptions.Add(taskEx);
                        changeSetProperty.OnChangeSetCompleted();
                        tcs.SetException(taskEx.Demystify());
                    }
                    else
                    {
                        tcs.SetResult(context);
                    }

                    return(tcs.Task);
                },
                        context.RequestAborted);

                responseTasks.Add(task);
            }

            // the responseTasks will be complete after:
            // - the ChangeSet is submitted
            // - the responses are created and
            // - the controller actions have returned
            await Task.WhenAll(responseTasks).ConfigureAwait(false);

            var returnContexts = new List <HttpContext>();

            foreach (var responseTask in responseTasks)
            {
                var returnContext = responseTask.Result.Result;
                if (returnContext.Response.IsSuccessStatusCode())
                {
                    returnContexts.Add(returnContext);
                }
                else
                {
                    returnContexts.Clear();
                    returnContexts.Add(returnContext);
                    return(new ChangeSetResponseItem(returnContexts));
                }
            }

            return(new ChangeSetResponseItem(returnContexts));
        }
Пример #13
0
 public async Task SendMessageAsync_Throws_WhenRequestIsNull()
 {
     await ExceptionAssert.ThrowsArgumentNullAsync(
         () => ODataBatchRequestItem.SendMessageAsync(new HttpMessageInvoker(new HttpServer()), null, CancellationToken.None, null),
         "request");
 }
Пример #14
0
 public async Task SendMessageAsync_Throws_WhenInvokerIsNull()
 {
     await ExceptionAssert.ThrowsArgumentNullAsync(
         () => ODataBatchRequestItem.SendMessageAsync(null, new HttpRequestMessage(), CancellationToken.None, null),
         "invoker");
 }