Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Web.Http.Test/Routing/HttpRouteTest.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Net.Http;
+using Xunit;
+using Xunit.Extensions;
+
+namespace System.Web.Http.Routing
+{
+    public class HttpRouteTest
+    {
+        [Theory]
+        [InlineData("123 456")]
+        [InlineData("123 {456")]
+        [InlineData("123 [45]6")]
+        [InlineData("123 (4)56")]
+        [InlineData("abc+56")]
+        [InlineData("abc.56")]
+        [InlineData("abc*56")]
+        [InlineData(@"hello12.1[)]*^$=!@23}")]
+        public void GetRouteData_HandlesUrlEncoding(string id)
+        {
+            HttpRoute route = new HttpRoute("{controller}/{id}");
+            Uri uri = new Uri("http://localhost/test/" + Uri.EscapeDataString(id) + "/");
+            IHttpRouteData routeData = route.GetRouteData("", new HttpRequestMessage(HttpMethod.Get, uri));
+            Assert.Equal("test", routeData.Values["controller"]);
+            Assert.Equal(id, routeData.Values["id"]);
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Test/Routing/MediaTypeFormatterExtensionsTests.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Net.Http.Headers;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http.Formatting
+{
+    public class MediaTypeFormatterExtensionsTests
+    {
+        [Fact]
+        public void AddUriPathExtensionMapping_MediaTypeHeaderValue_ThrowsWithNullThis()
+        {
+            MediaTypeFormatter formatter = null;
+            Assert.ThrowsArgumentNull(() => formatter.AddUriPathExtensionMapping("xml", new MediaTypeHeaderValue("application/xml")), "formatter");
+        }
+
+        [Fact]
+        public void AddUriPathExtensionMapping_MediaTypeHeaderValue_UpdatesMediaTypeMappingsCollection()
+        {
+            MediaTypeFormatter mockFormatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;
+
+            mockFormatter.AddUriPathExtensionMapping("ext", new MediaTypeHeaderValue("application/test"));
+
+            Assert.Equal(1, mockFormatter.MediaTypeMappings.Count);
+            Assert.IsType(typeof(UriPathExtensionMapping), mockFormatter.MediaTypeMappings[0]);
+            Assert.Equal("ext", (mockFormatter.MediaTypeMappings[0] as UriPathExtensionMapping).UriPathExtension);
+            Assert.Equal("application/test", (mockFormatter.MediaTypeMappings[0] as UriPathExtensionMapping).MediaType.MediaType);
+        }
+
+        [Fact]
+        public void AddUriPathExtensionMapping_MediaType_ThrowsWithNullThis()
+        {
+            MediaTypeFormatter formatter = null;
+            Assert.ThrowsArgumentNull(() => formatter.AddUriPathExtensionMapping("xml", "application/xml"), "formatter");
+        }
+
+        [Fact]
+        public void AddUriPathExtensionMapping_MediaType_UpdatesMediaTypeMappingsCollection()
+        {
+            MediaTypeFormatter mockFormatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;
+
+            mockFormatter.AddUriPathExtensionMapping("ext", "application/test");
+
+            Assert.Equal(1, mockFormatter.MediaTypeMappings.Count);
+            Assert.IsType(typeof(UriPathExtensionMapping), mockFormatter.MediaTypeMappings[0]);
+            Assert.Equal("ext", (mockFormatter.MediaTypeMappings[0] as UriPathExtensionMapping).UriPathExtension);
+            Assert.Equal("application/test", (mockFormatter.MediaTypeMappings[0] as UriPathExtensionMapping).MediaType.MediaType);
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Test/Routing/UriPathExtensionMappingTests.cs

@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Net.Http.Formatting.DataSets;
+using System.Net.Http.Headers;
+using System.Web.Http.Hosting;
+using System.Web.Http.Routing;
+using Microsoft.TestCommon;
+using Moq;
+using Xunit;
+using Xunit.Extensions;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http.Formatting
+{
+    public class UriPathExtensionMappingTests
+    {
+        [Fact]
+        public void TypeIsCorrect()
+        {
+            Assert.Type.HasProperties(
+                typeof(UriPathExtensionMapping),
+                TypeAssert.TypeProperties.IsPublicVisibleClass,
+                typeof(MediaTypeMapping));
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings")]
+        public void ConstructorMediaType_Initialises_MediaTypeAndUriPathExtension(string uriPathExtension, string mediaType)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
+            Assert.Equal(uriPathExtension, mapping.UriPathExtension);
+            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "Failed to set MediaType.");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(CommonUnitTestDataSets), "EmptyStrings",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings")]
+        public void ConstructorMediaType_ThrowsWithEmptyUriPathExtension(string uriPathExtension, string mediaType)
+        {
+            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "uriPathExtension");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(CommonUnitTestDataSets), "EmptyStrings")]
+        public void ConstructorMediaType_ThrowsWithEmptyMediaType(string uriPathExtension, string mediaType)
+        {
+            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "mediaType");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeHeaderValues")]
+        public void ConstructorMediaTypeHeaderValue_Initialises_MediaTypeAndUriPathExtension(string uriPathExtension, MediaTypeHeaderValue mediaType)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
+            Assert.Equal(uriPathExtension, mapping.UriPathExtension);
+            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "Failed to set MediaType.");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(CommonUnitTestDataSets), "EmptyStrings",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeHeaderValues")]
+        [Trait("Description", "UriPathExtensionMapping(string, MediaTypeHeaderValue) throws if the UriPathExtensions parameter is null.")]
+        public void ConstructorMediaTypeHeaderValue_ThrowsWithEmptyUriPathExtension(string uriPathExtension, MediaTypeHeaderValue mediaType)
+        {
+            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "uriPathExtension");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions")]
+        [Trait("Description", "UriPathExtensionMapping(string, MediaTypeHeaderValue) constructor throws if the mediaType parameter is null.")]
+        public void ConstructorMediaTypeHeaderValue_ThrowsWithEmptyMediaType(string uriPathExtension)
+        {
+            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, (MediaTypeHeaderValue)null), "mediaType");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings",
+            typeof(HttpUnitTestDataSets), "UriStrings")]
+        [Trait("Description", "TryMatchMediaType(HttpRequestMessage) returns 1.0 when the extension is in the Uri.")]
+        public void TryMatchMediaType_Returns_MatchWithExtensionInRouteData(string uriPathExtension, string mediaType, string baseUriString)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
+            HttpRequestMessage request = GetRequestWithExtInRouteData(uriPathExtension);
+            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings",
+            typeof(HttpUnitTestDataSets), "UriStrings")]
+        [Trait("Description", "TryMatchMediaType(HttpRequestMessage) returns 1.0 when the extension is in the Uri but differs in case")]
+        public void TryMatchMediaType_Returns_MatchWithExtensionInRouteData_DifferCase(string uriPathExtension, string mediaType, string baseUriString)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension.ToUpperInvariant(), mediaType);
+            HttpRequestMessage request = GetRequestWithExtInRouteData(uriPathExtension.ToLowerInvariant());
+            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings",
+            typeof(HttpUnitTestDataSets), "UriStrings")]
+        [Trait("Description", "TryMatchMediaType(HttpRequestMessage) returns 0.0 when the extension is not in the Uri.")]
+        public void TryMatchMediaType_Returns_ZeroWithExtensionNotInRouteData(string uriPathExtension, string mediaType, string baseUriString)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
+            Uri uri = new Uri(baseUriString);
+            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
+            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(HttpUnitTestDataSets), "LegalUriPathExtensions",
+            typeof(HttpUnitTestDataSets), "LegalMediaTypeStrings")]
+        [Trait("Description", "TryMatchMediaType(HttpRequestMessage) throws if the request is null.")]
+        public void TryMatchMediaType_Throws_WithNullHttpRequestMessage(string uriPathExtension, string mediaType)
+        {
+            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
+            Assert.ThrowsArgumentNull(() => mapping.TryMatchMediaType(request: null), "request");
+        }
+
+        private static HttpRequestMessage GetRequestWithExtInRouteData(string extensionValue)
+        {
+            IHttpRoute route = new Mock<IHttpRoute>().Object;
+            IHttpRouteData routeData = new HttpRouteData(route);
+            routeData.Values[UriPathExtensionMapping.UriPathExtensionKey] = extensionValue;
+
+            HttpRequestMessage request = new HttpRequestMessage();
+            request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
+
+            return request;
+        }
+    }
+}

external/aspnetwebstack/test/System.Web.Http.Test/Routing/UrlHelperTest.cs

@@ -0,0 +1,206 @@
+// 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.Web.Http.Controllers;
+using Microsoft.TestCommon;
+using Xunit;
+using Xunit.Extensions;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Web.Http.Routing
+{
+    public class UrlHelperTest
+    {
+        [Fact]
+        public void UrlHelper_CtorThrows_WithNullContext()
+        {
+            Assert.ThrowsArgumentNull(
+                () => new UrlHelper(null),
+                "controllerContext");
+        }
+
+        [Fact]
+        public void ControllerContext_HasUrlHelperWithValidContext()
+        {
+            HttpControllerContext cc = new HttpControllerContext();
+
+            Assert.NotNull(cc.Url);
+            Assert.IsType<UrlHelper>(cc.Url);
+            Assert.Same(cc, cc.Url.ControllerContext);
+        }
+
+        [Theory]
+        [PropertyData("UrlGeneratorTestData")]
+        public void UrlHelper_UsesCurrentRouteDataToPopulateValues_WithObjectValues(string controller, int? id, string expectedUrl)
+        {
+            var url = GetUrlHelperForApi();
+            object routeValues = GetRouteValuesAsObject(controller, id);
+
+            string generatedUrl = url.Route("route1", routeValues);
+
+            Assert.Equal(expectedUrl, generatedUrl);
+        }
+
+        [Theory]
+        [PropertyData("UrlGeneratorTestData")]
+        public void UrlHelper_UsesCurrentRouteDataToPopulateValues_WithDictionaryValues(string controller, int? id, string expectedUrl)
+        {
+            var url = GetUrlHelperForApi();
+            Dictionary<string, object> routeValues = GetRouteValuesAsDictionary(controller, id);
+
+            string generatedUrl = url.Route("route1", routeValues);
+
+            Assert.Equal(expectedUrl, generatedUrl);
+        }
+
+        [Fact]
+        public void UrlHelper_Throws_WhenWrongNameUsed_WithObjectValues()
+        {
+            var url = GetUrlHelperForApi();
+            Assert.ThrowsArgument(
+                () => url.Route("route-doesn't-exist", null),
+                "name",
+                "A route named 'route-doesn't-exist' could not be found in the route collection.");
+        }
+
+        [Fact]
+        public void UrlHelper_Throws_WhenWrongNameUsed_WithDictionaryValues()
+        {
+            var url = GetUrlHelperForApi();
+            Assert.ThrowsArgument(
+                () => url.Route("route-doesn't-exist", (IDictionary<string, object>)null),
+                "name",
+                "A route named 'route-doesn't-exist' could not be found in the route collection.");
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(UrlHelperTest), "UrlGeneratorTestData",
+            typeof(UrlHelperTest), "RequestUrlTestData")]
+        public void UrlHelper_LinkGeneration_GeneratesRightLinksWithDictionary(string controller, int? id, string expectedUrl, string requestUrl)
+        {
+            var urlHelper = GetUrlHelperForApi();
+            urlHelper.ControllerContext.Request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+            Dictionary<string, object> routeValues = GetRouteValuesAsDictionary(controller, id);
+            string baseUrl = new Uri(requestUrl).GetLeftPart(UriPartial.Authority);
+
+            string generatedlink = urlHelper.Link("route1", routeValues);
+
+            Assert.Equal(expectedUrl != null ? baseUrl + expectedUrl : null, generatedlink);
+        }
+
+        [Theory]
+        [TestDataSet(
+            typeof(UrlHelperTest), "UrlGeneratorTestData",
+            typeof(UrlHelperTest), "RequestUrlTestData")]
+        public void UrlHelper_LinkGeneration_GeneratesRightLinksWithObject(string controller, int? id, string expectedUrl, string requestUrl)
+        {
+            var urlHelper = GetUrlHelperForApi();
+            urlHelper.ControllerContext.Request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
+            object routeValues = GetRouteValuesAsObject(controller, id);
+            string baseUrl = new Uri(requestUrl).GetLeftPart(UriPartial.Authority);
+
+            string generatedlink = urlHelper.Link("route1", routeValues);
+
+            Assert.Equal(expectedUrl != null ? baseUrl + expectedUrl : null, generatedlink);
+        }
+
+        private static UrlHelper GetUrlHelperForApi()
+        {
+            HttpControllerContext cc = new HttpControllerContext();
+
+            // Set up routes
+            var routes = new HttpRouteCollection("/somerootpath");
+            IHttpRoute route = routes.MapHttpRoute("route1", "{controller}/{id}");
+            cc.Configuration = new HttpConfiguration(routes);
+
+            cc.RouteData = new HttpRouteData(route, new HttpRouteValueDictionary(new { controller = "people", id = "123" }));
+
+            return cc.Url;
+        }
+
+        private static object GetRouteValuesAsObject(string controller, int? id)
+        {
+            object routeValues = null;
+            if (controller == null)
+            {
+                if (id == null)
+                {
+                    routeValues = null;
+                }
+                else
+                {
+                    routeValues = new { id };
+                }
+            }
+            else
+            {
+                if (id == null)
+                {
+                    routeValues = new { controller };
+                }
+                else
+                {
+                    routeValues = new { controller, id };
+                }
+            }
+
+            return routeValues;
+        }
+
+        private static Dictionary<string, object> GetRouteValuesAsDictionary(string controller, int? id)
+        {
+            Dictionary<string, object> routeValues = new Dictionary<string, object>();
+            if (controller == null)
+            {
+                if (id == null)
+                {
+                    routeValues = null;
+                }
+                else
+                {
+                    routeValues.Add("id", id);
+                }
+            }
+            else
+            {
+                if (id == null)
+                {
+                    routeValues.Add("controller", controller);
+                }
+                else
+                {
+                    routeValues.Add("controller", controller);
+                    routeValues.Add("id", id);
+                }
+            }
+
+            return routeValues;
+        }
+
+        public static IEnumerable<object[]> UrlGeneratorTestData
+        {
+            get
+            {
+                return new TheoryDataSet<string, int?, string>()
+                {
+                    { null, 456, "/somerootpath/people/456"}, // Just override ID, so ID is replaced
+                    { "people", 456, "/somerootpath/people/456"}, // Just override ID, so ID is replaced
+                    { null, null, "/somerootpath/people/123"}, // Override nothing, so everything the same
+                    { "people", null, "/somerootpath/people/123"}, // Override nothing, so everything the same
+                    { "customers", 456, "/somerootpath/customers/456"}, // Override everything, so everything changed
+                    { "customers", null, null}, // Override controller, which clears out the ID, so it doesn't match (i.e. null)
+                };
+            }
+        }
+
+        public static IEnumerable<object> RequestUrlTestData
+        {
+            get
+            {
+                return new[] { "http://localhost", "http://localhost/123", "http://localhost/123?q=odata&$filter=123#123" };
+            }
+        }
+    }
+}