Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/AcceptHeaderTests.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Net.Http;
+using System.Net.Http.Headers;
+using Xunit;
+using Xunit.Extensions;
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class AcceptHeaderTests : ContentNegotiationTestBase
+    {
+        [Theory]
+        [InlineData("application/json")]
+        [InlineData("application/xml")]
+        public void Response_Contains_ContentType(string contentType)
+        {
+            // Arrange
+            MediaTypeWithQualityHeaderValue requestContentType = new MediaTypeWithQualityHeaderValue(contentType);
+            MediaTypeHeaderValue responseContentType = null;
+
+            // Act
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseUri);
+            request.Headers.Accept.Add(requestContentType);
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+            response.EnsureSuccessStatusCode();
+            responseContentType = response.Content.Headers.ContentType;
+
+            // Assert
+            Assert.Equal(requestContentType.MediaType, responseContentType.MediaType);
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/ConnegController.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class ConnegController : ApiController
+    {
+        public ConnegItem GetItem(string name = "Fido", int age = 3)
+        {
+            return new ConnegItem()
+            {
+                Name = name,
+                Age = age
+            };
+        }
+
+        public ConnegItem PostItem(ConnegItem item)
+        {
+            return item;
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/ConnegItem.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class ConnegItem
+    {
+        public string Name { get; set; }
+        public int Age { get; set; }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/ContentNegotiationTestBase.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Net.Http;
+using System.Web.Http.SelfHost;
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class ContentNegotiationTestBase : IDisposable
+    {
+        protected readonly string baseUri = "http://localhost:8080/Conneg";
+        protected HttpSelfHostServer server = null;
+        protected HttpSelfHostConfiguration configuration = null;
+        protected HttpClient httpClient = null;
+
+        public ContentNegotiationTestBase()
+        {
+            this.SetupHost();
+        }
+
+        public void Dispose()
+        {
+            this.CleanupHost();
+        }
+
+        public void SetupHost()
+        {
+            configuration = new HttpSelfHostConfiguration(baseUri);
+            configuration.Routes.MapHttpRoute("Default", "{controller}", new { controller = "Conneg" });
+            server = new HttpSelfHostServer(configuration);
+            server.OpenAsync().Wait();
+
+            httpClient = new HttpClient();
+        }
+
+        public void CleanupHost()
+        {
+            if (server != null)
+            {
+                server.CloseAsync().Wait();
+            }
+
+            if (httpClient != null)
+            {
+                httpClient.Dispose();
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/CustomFormatterTests.cs

@@ -0,0 +1,275 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using System.Web.Http.SelfHost;
+using Xunit;
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class CustomFormatterTests : IDisposable
+    {
+        private HttpSelfHostServer server = null;
+        private string baseAddress = null;
+        private HttpClient httpClient = null;
+        private HttpSelfHostConfiguration config = null;
+
+        public CustomFormatterTests()
+        {
+            SetupHost();
+        }
+
+        public void Dispose()
+        {
+            this.CleanupHost();
+        }
+
+        [Fact]
+        public void CustomFormatter_Overrides_SetResponseHeaders_During_Conneg()
+        {
+            Order reqOrdr = new Order() { OrderId = "100", OrderValue = 100.00 };
+            HttpRequestMessage request = new HttpRequestMessage
+            {
+                Content = new ObjectContent<Order>(reqOrdr, new XmlMediaTypeFormatter())
+            };
+            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoOrder");
+            request.Method = HttpMethod.Post;
+            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/plainwithversioninfo"));
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            response.EnsureSuccessStatusCode();
+
+            IEnumerable<string> versionHdr = null;
+            Assert.True(response.Headers.TryGetValues("Version", out versionHdr));
+            Assert.Equal<string>("1.3.5.0", versionHdr.First());
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("text/plainwithversioninfo", response.Content.Headers.ContentType.MediaType);
+        }
+
+        [Fact]
+        public void CustomFormatter_Post_Returns_Request_String_Content()
+        {
+            HttpRequestMessage request = new HttpRequestMessage
+            {
+                Content = new ObjectContent<string>("Hello World!", new PlainTextFormatter())
+            };
+            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoString");
+            request.Method = HttpMethod.Post;
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            response.EnsureSuccessStatusCode();
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("text/plain", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal<string>("Hello World!", response.Content.ReadAsStringAsync().Result);
+        }
+
+        [Fact(Skip = "Test update needed, uses IKeyValueModel")]
+        public void CustomFormatter_Post_Returns_Request_Integer_Content()
+        {
+            HttpRequestMessage request = new HttpRequestMessage
+            {
+                Content = new ObjectContent<int>(100, new PlainTextFormatter())
+            };
+
+            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoInt");
+            request.Method = HttpMethod.Post;
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            response.EnsureSuccessStatusCode();
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("text/plain", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal<int>(100, Convert.ToInt32(response.Content.ReadAsStringAsync().Result));
+        }
+
+
+        [Fact(Skip = "Test update needed, uses IKeyValueModel")]
+        public void CustomFormatter_Post_Returns_Request_ComplexType_Content()
+        {
+            Order reqOrdr = new Order() { OrderId = "100", OrderValue = 100.00 };
+            HttpRequestMessage request = new HttpRequestMessage
+            {
+                Content = new ObjectContent<Order>(reqOrdr, new PlainTextFormatter())
+            };
+            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoOrder");
+            request.Method = HttpMethod.Post;
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            response.EnsureSuccessStatusCode();
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("text/plain", response.Content.Headers.ContentType.MediaType);
+        }
+
+        private void SetupHost()
+        {
+            httpClient = new HttpClient();
+            baseAddress = String.Format("http://{0}", Environment.MachineName);
+            config = new HttpSelfHostConfiguration(baseAddress);
+            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "CustomFormatterTests", action = "EchoOrder" });
+            config.Formatters.Add(new PlainTextFormatterWithVersionInfo());
+            config.Formatters.Add(new PlainTextFormatter());
+
+            server = new HttpSelfHostServer(config);
+            server.OpenAsync().Wait();
+        }
+
+        private void CleanupHost()
+        {
+            if (server != null)
+            {
+                server.CloseAsync().Wait();
+            }
+        }
+    }
+
+    public class PlainTextFormatterWithVersionInfo : MediaTypeFormatter
+    {
+        public PlainTextFormatterWithVersionInfo()
+        {
+            this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plainwithversioninfo"));
+        }
+
+        public override bool CanReadType(Type type)
+        {
+            return true;
+        }
+
+        public override bool CanWriteType(Type type)
+        {
+            return true;
+        }
+
+        public override void SetDefaultContentHeaders(Type objectType, HttpContentHeaders contentHeaders, string mediaType)
+        {
+            base.SetDefaultContentHeaders(objectType, contentHeaders, mediaType);
+            contentHeaders.TryAddWithoutValidation("Version", "1.3.5.0");
+        }
+
+        public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger)
+        {
+            string content = null;
+
+            using (var reader = new StreamReader(stream))
+            {
+                content = reader.ReadToEnd();
+            }
+
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            tcs.SetResult(content);
+
+            return tcs.Task;
+        }
+
+        public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
+        {
+            var output = value.ToString();
+            var writer = new StreamWriter(stream);
+            writer.Write(output);
+            writer.Flush();
+
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            tcs.SetResult(null);
+
+            return tcs.Task;
+        }
+    }
+
+    public class PlainTextFormatter : MediaTypeFormatter
+    {
+        public PlainTextFormatter()
+        {
+            this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plain"));
+        }
+
+        public override bool CanReadType(Type type)
+        {
+            return true;
+        }
+
+        public override bool CanWriteType(Type type)
+        {
+            return true;
+        }
+
+        public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger)
+        {
+            string content = null;
+
+            using (var reader = new StreamReader(stream))
+            {
+                content = reader.ReadToEnd();
+            }
+
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            tcs.SetResult(content);
+            return tcs.Task;
+        }
+
+        public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
+        {
+            var output = value == null ? String.Empty : value.ToString();
+            var writer = new StreamWriter(stream);
+            writer.Write(output);
+            writer.Flush();
+
+            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+            tcs.SetResult(null);
+            return tcs.Task;
+        }
+    }
+
+    public class CustomFormatterTestsController : ApiController
+    {
+        [HttpPost]
+        public string EchoString([FromBody] string input)
+        {
+            return input;
+        }
+
+        [HttpPost]
+        public int EchoInt([FromBody] int input)
+        {
+            return input;
+        }
+
+        [HttpPost]
+        public Order EchoOrder(Order order)
+        {
+            return order;
+        }
+    }
+
+    public class Order : IEquatable<Order>, ICloneable
+    {
+        public string OrderId { get; set; }
+        public double OrderValue { get; set; }
+
+        public bool Equals(Order other)
+        {
+            return (this.OrderId.Equals(other.OrderId) && this.OrderValue.Equals(other.OrderValue));
+        }
+
+        public object Clone()
+        {
+            return this.MemberwiseClone();
+        }
+
+        public override string ToString()
+        {
+            return String.Format("OrderId:{0}, OrderValue:{1}", OrderId, OrderValue);
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/DefaultContentNegotiatorTests.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using Moq;
+using Xunit;
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class DefaultContentNegotiatorTests : ContentNegotiationTestBase
+    {
+        [Fact]
+        public void Custom_ContentNegotiator_Used_In_Response()
+        {
+            // Arrange
+            configuration.Formatters.Clear();
+            MediaTypeWithQualityHeaderValue requestContentType = new MediaTypeWithQualityHeaderValue("application/xml");
+            MediaTypeHeaderValue responseContentType = null;
+
+            Mock<IContentNegotiator> selector = new Mock<IContentNegotiator>();
+            selector.Setup(s => s.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(), It.IsAny<IEnumerable<MediaTypeFormatter>>()))
+                .Returns(new ContentNegotiationResult(new XmlMediaTypeFormatter(), null));
+
+            configuration.Services.Replace(typeof(IContentNegotiator), selector.Object);
+
+            // Act
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseUri);
+            request.Headers.Accept.Add(requestContentType);
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+            response.EnsureSuccessStatusCode();
+            responseContentType = response.Content.Headers.ContentType;
+
+            // Assert
+            selector.Verify(s => s.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(), It.IsAny<IEnumerable<MediaTypeFormatter>>()), Times.AtLeastOnce());
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Integration.Test/ContentNegotiation/HttpResponseReturnTests.cs

@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Web.Http.SelfHost;
+using Xunit;
+using Xunit.Extensions;
+
+namespace System.Web.Http.ContentNegotiation
+{
+    public class HttpResponseReturnTests : IDisposable
+    {
+        private HttpSelfHostServer server = null;
+        private string baseAddress = null;
+        private HttpClient httpClient = null;
+
+        public HttpResponseReturnTests()
+        {
+            this.SetupHost();
+        }
+
+        public void Dispose()
+        {
+            this.CleanupHost();
+        }
+
+        [Theory]
+        [InlineData("ReturnHttpResponseMessage")]
+        [InlineData("ReturnHttpResponseMessageAsObject")]
+        [InlineData("ReturnString")]
+        public void ActionReturnsHttpResponseMessage(string action)
+        {
+            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello</string>";
+
+            HttpRequestMessage request = new HttpRequestMessage();
+            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
+            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
+            request.Method = HttpMethod.Get;
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("application/xml", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal<string>(expectedResponseValue, response.Content.ReadAsStringAsync().Result);
+        }
+
+        [Theory]
+        [InlineData("ReturnHttpResponseMessageAsXml")]
+        public void ActionReturnsHttpResponseMessageWithExplicitMediaType(string action)
+        {
+            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello</string>";
+
+            HttpRequestMessage request = new HttpRequestMessage();
+            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
+            request.Method = HttpMethod.Get;
+
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+
+            Assert.NotNull(response.Content);
+            Assert.NotNull(response.Content.Headers.ContentType);
+            Assert.Equal<string>("application/xml", response.Content.Headers.ContentType.MediaType);
+            Assert.Equal<string>(expectedResponseValue, response.Content.ReadAsStringAsync().Result);
+        }
+
+        [Theory]
+        [InlineData("ReturnMultipleSetCookieHeaders")]
+        public void ReturnMultipleSetCookieHeadersShouldWork(string action)
+        {
+            HttpRequestMessage request = new HttpRequestMessage();
+            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
+            request.Method = HttpMethod.Get;
+            HttpResponseMessage response = httpClient.SendAsync(request).Result;
+            response.EnsureSuccessStatusCode();
+            IEnumerable<string> list;
+            Assert.True(response.Headers.TryGetValues("Set-Cookie",  out list));
+            Assert.Equal("cookie1,cookie2", ((string[]) list)[0]);
+        }
+
+        public void SetupHost()
+        {
+            httpClient = new HttpClient();
+
+            baseAddress = String.Format("http://{0}/", Environment.MachineName);
+
+            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
+            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "HttpResponseReturn" });
+
+            server = new HttpSelfHostServer(config);
+            server.OpenAsync().Wait();
+        }
+
+        public void CleanupHost()
+        {
+            if (server != null)
+            {
+                server.CloseAsync().Wait();
+            }
+        }
+    }
+
+    public class HttpResponseReturnController : ApiController
+    {
+        [HttpGet]
+        public HttpResponseMessage ReturnHttpResponseMessage()
+        {
+            return Request.CreateResponse(HttpStatusCode.OK, "Hello");
+        }
+
+        [HttpGet]
+        public object ReturnHttpResponseMessageAsObject()
+        {
+            return ReturnHttpResponseMessage();
+        }
+
+        [HttpGet]
+        public HttpResponseMessage ReturnHttpResponseMessageAsXml()
+        {
+            HttpResponseMessage response = new HttpResponseMessage()
+            {
+                Content = new ObjectContent<string>("Hello", new XmlMediaTypeFormatter())
+            };
+            return response;
+        }
+
+        [HttpGet]
+        public string ReturnString()
+        {
+            return "Hello";
+        }
+
+        [HttpGet]
+        public HttpResponseMessage ReturnMultipleSetCookieHeaders()
+        {
+            HttpResponseMessage resp = new HttpResponseMessage(HttpStatusCode.OK);
+            resp.Headers.Add("Set-Cookie", "cookie1");
+            resp.Headers.Add("Set-Cookie", "cookie2");
+            return resp; 
+        }
+    }
+}