Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/AjaxOnlyAttributeTest.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Specialized;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class AjaxOnlyAttributeTest
+    {
+        [Fact]
+        public void IsValidForRequestReturnsFalseIfHeaderNotPresent()
+        {
+            // Arrange
+            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();
+            ControllerContext controllerContext = GetControllerContext(containsHeader: false);
+
+            // Act
+            bool isValid = attr.IsValidForRequest(controllerContext, null);
+
+            // Assert
+            Assert.False(isValid);
+        }
+
+        [Fact]
+        public void IsValidForRequestReturnsTrueIfHeaderIsPresent()
+        {
+            // Arrange
+            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();
+            ControllerContext controllerContext = GetControllerContext(containsHeader: true);
+
+            // Act
+            bool isValid = attr.IsValidForRequest(controllerContext, null);
+
+            // Assert
+            Assert.True(isValid);
+        }
+
+        [Fact]
+        public void IsValidForRequestThrowsIfControllerContextIsNull()
+        {
+            // Arrange
+            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();
+
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { attr.IsValidForRequest(null, null); }, "controllerContext");
+        }
+
+        private static ControllerContext GetControllerContext(bool containsHeader)
+        {
+            Mock<ControllerContext> mockContext = new Mock<ControllerContext> { DefaultValue = DefaultValue.Mock };
+
+            NameValueCollection nvc = new NameValueCollection();
+            if (containsHeader)
+            {
+                nvc["X-Requested-With"] = "XMLHttpRequest";
+            }
+
+            mockContext.Setup(o => o.HttpContext.Request.Headers).Returns(nvc);
+            mockContext.Setup(o => o.HttpContext.Request["X-Requested-With"]).Returns("XMLHttpRequest"); // always assume the request contains this, e.g. as a form value
+
+            return mockContext.Object;
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/AreaHelpersTest.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Web;
+using System.Web.Mvc;
+using System.Web.Routing;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class AreaHelpersTest
+    {
+        [Fact]
+        public void GetAreaNameFromAreaRouteCollectionRoute()
+        {
+            // Arrange
+            RouteCollection routes = new RouteCollection();
+            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
+            Route route = context.MapRoute(null, "the_url");
+
+            // Act
+            string areaName = AreaHelpers.GetAreaName(route);
+
+            // Assert
+            Assert.Equal("area_name", areaName);
+        }
+
+        [Fact]
+        public void GetAreaNameFromIAreaAssociatedItem()
+        {
+            // Arrange
+            CustomRouteWithArea route = new CustomRouteWithArea();
+
+            // Act
+            string areaName = AreaHelpers.GetAreaName(route);
+
+            // Assert
+            Assert.Equal("area_name", areaName);
+        }
+
+        [Fact]
+        public void GetAreaNameFromRouteData()
+        {
+            // Arrange
+            RouteData routeData = new RouteData();
+            routeData.DataTokens["area"] = "area_name";
+
+            // Act
+            string areaName = AreaHelpers.GetAreaName(routeData);
+
+            // Assert
+            Assert.Equal("area_name", areaName);
+        }
+
+        [Fact]
+        public void GetAreaNameFromRouteDataFallsBackToRoute()
+        {
+            // Arrange
+            RouteCollection routes = new RouteCollection();
+            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
+            Route route = context.MapRoute(null, "the_url");
+            RouteData routeData = new RouteData(route, new MvcRouteHandler());
+
+            // Act
+            string areaName = AreaHelpers.GetAreaName(routeData);
+
+            // Assert
+            Assert.Equal("area_name", areaName);
+        }
+
+        [Fact]
+        public void GetAreaNameReturnsNullIfRouteNotAreaAware()
+        {
+            // Arrange
+            Route route = new Route("the_url", new MvcRouteHandler());
+
+            // Act
+            string areaName = AreaHelpers.GetAreaName(route);
+
+            // Assert
+            Assert.Null(areaName);
+        }
+
+        private class CustomRouteWithArea : RouteBase, IRouteWithArea
+        {
+            public string Area
+            {
+                get { return "area_name"; }
+            }
+
+            public override RouteData GetRouteData(HttpContextBase httpContext)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/AsyncManagerExtensionsTest.cs

@@ -0,0 +1,190 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Threading;
+using System.Web.Mvc.Async;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class AsyncManagerExtensionsTest
+    {
+        [Fact]
+        public void RegisterTask_AsynchronousCompletion()
+        {
+            // Arrange
+            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
+            AsyncManager asyncManager = new AsyncManager(syncContext);
+            bool endDelegateWasCalled = false;
+
+            ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */);
+
+            Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
+            {
+                Assert.Equal(1, asyncManager.OutstandingOperations.Count);
+                MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */);
+                ThreadPool.QueueUserWorkItem(_ =>
+                {
+                    Assert.Equal(1, asyncManager.OutstandingOperations.Count);
+                    callback(asyncResult);
+                    waitHandle.Set();
+                });
+                return asyncResult;
+            };
+            Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; };
+
+            // Act
+            asyncManager.RegisterTask(beginDelegate, endDelegate);
+            waitHandle.WaitOne();
+
+            // Assert
+            Assert.True(endDelegateWasCalled);
+            Assert.True(syncContext.SendWasCalled);
+            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
+        }
+
+        [Fact]
+        public void RegisterTask_AsynchronousCompletion_SwallowsExceptionsThrownByEndDelegate()
+        {
+            // Arrange
+            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
+            AsyncManager asyncManager = new AsyncManager(syncContext);
+            bool endDelegateWasCalled = false;
+
+            ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */);
+
+            Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
+            {
+                MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */);
+                ThreadPool.QueueUserWorkItem(_ =>
+                {
+                    callback(asyncResult);
+                    waitHandle.Set();
+                });
+                return asyncResult;
+            };
+            Action<IAsyncResult> endDelegate = delegate
+            {
+                endDelegateWasCalled = true;
+                throw new Exception("This is a sample exception.");
+            };
+
+            // Act
+            asyncManager.RegisterTask(beginDelegate, endDelegate);
+            waitHandle.WaitOne();
+
+            // Assert
+            Assert.True(endDelegateWasCalled);
+            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
+        }
+
+        [Fact]
+        public void RegisterTask_ResetsOutstandingOperationCountIfBeginMethodThrows()
+        {
+            // Arrange
+            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
+            AsyncManager asyncManager = new AsyncManager(syncContext);
+
+            Func<AsyncCallback, IAsyncResult> beginDelegate = cb => { throw new InvalidOperationException("BeginDelegate throws."); };
+            Action<IAsyncResult> endDelegate = ar => { Assert.True(false, "This should never be called."); };
+
+            // Act & assert
+            Assert.Throws<InvalidOperationException>(
+                delegate { asyncManager.RegisterTask(beginDelegate, endDelegate); }, "BeginDelegate throws.");
+
+            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
+        }
+
+        [Fact]
+        public void RegisterTask_SynchronousCompletion()
+        {
+            // Arrange
+            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
+            AsyncManager asyncManager = new AsyncManager(syncContext);
+            bool endDelegateWasCalled = false;
+
+            Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
+            {
+                Assert.Equal(1, asyncManager.OutstandingOperations.Count);
+                MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */);
+                callback(asyncResult);
+                return asyncResult;
+            };
+            Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; };
+
+            // Act
+            asyncManager.RegisterTask(beginDelegate, endDelegate);
+
+            // Assert
+            Assert.True(endDelegateWasCalled);
+            Assert.False(syncContext.SendWasCalled);
+            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
+        }
+
+        [Fact]
+        public void RegisterTask_ThrowsIfAsyncManagerIsNull()
+        {
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { AsyncManagerExtensions.RegisterTask(null, _ => null, _ => { }); }, "asyncManager");
+        }
+
+        [Fact]
+        public void RegisterTask_ThrowsIfBeginDelegateIsNull()
+        {
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { new AsyncManager().RegisterTask(null, _ => { }); }, "beginDelegate");
+        }
+
+        [Fact]
+        public void RegisterTask_ThrowsIfEndDelegateIsNull()
+        {
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { new AsyncManager().RegisterTask(_ => null, null); }, "endDelegate");
+        }
+
+        private class SimpleSynchronizationContext : SynchronizationContext
+        {
+            public bool SendWasCalled;
+
+            public override void Send(SendOrPostCallback d, object state)
+            {
+                SendWasCalled = true;
+                d(state);
+            }
+        }
+
+        private class MockAsyncResult : IAsyncResult
+        {
+            private readonly bool _completedSynchronously;
+
+            public MockAsyncResult(bool completedSynchronously)
+            {
+                _completedSynchronously = completedSynchronously;
+            }
+
+            public object AsyncState
+            {
+                get { throw new NotImplementedException(); }
+            }
+
+            public WaitHandle AsyncWaitHandle
+            {
+                get { throw new NotImplementedException(); }
+            }
+
+            public bool CompletedSynchronously
+            {
+                get { return _completedSynchronously; }
+            }
+
+            public bool IsCompleted
+            {
+                get { throw new NotImplementedException(); }
+            }
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/ButtonTest.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Web.Mvc;
+using System.Web.Routing;
+using Microsoft.Web.UnitTestUtil;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class ButtonTest
+    {
+        [Fact]
+        public void ButtonWithNullNameThrowsArgumentNullException()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            Assert.ThrowsArgumentNull(() => html.Button(null, "text", HtmlButtonType.Button), "name");
+        }
+
+        [Fact]
+        public void ButtonRendersBaseAttributes()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr");
+            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void ButtonWithoutOnClickDoesNotRenderOnclickAttribute()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset);
+            Assert.Equal("<button name=\"nameAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void ButtonAllowsInnerHtml()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "<img src=\"puppy.jpg\" />", HtmlButtonType.Submit, "onclickAttr");
+            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" type=\"submit\"><img src=\"puppy.jpg\" /></button>", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void ButtonRendersExplicitAttributes()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr", new { title = "the-title" });
+            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" title=\"the-title\" type=\"reset\">buttonText</button>", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void ButtonRendersExplicitAttributesWithUnderscores()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr", new { foo_bar = "baz" });
+            Assert.Equal("<button foo-bar=\"baz\" name=\"nameAttr\" onclick=\"onclickAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void ButtonRendersExplicitDictionaryAttributes()
+        {
+            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
+            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Button, "onclickAttr", new RouteValueDictionary(new { title = "the-title" }));
+            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" title=\"the-title\" type=\"button\">buttonText</button>", result.ToHtmlString());
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/ContentTypeAttributeTest.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Web;
+using System.Web.Mvc;
+using System.Web.Routing;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class ContentTypeAttributeTest
+    {
+        [Fact]
+        public void ContentTypeSetInCtor()
+        {
+            var attr = new ContentTypeAttribute("text/html");
+            Assert.Equal("text/html", attr.ContentType);
+        }
+
+        [Fact]
+        public void ContentTypeCtorThrowsArgumentExceptionWhenContentTypeIsNull()
+        {
+            Assert.ThrowsArgumentNullOrEmpty(() => new ContentTypeAttribute(null), "contentType");
+        }
+
+        [Fact]
+        public void ExecuteResultSetsContentType()
+        {
+            var mockHttpResponse = new Mock<HttpResponseBase>();
+            var mockHttpContext = new Mock<HttpContextBase>();
+            mockHttpContext.Setup(c => c.Response).Returns(mockHttpResponse.Object);
+
+            var mockController = new Mock<Controller>();
+            var controllerContext = new ControllerContext(new RequestContext(mockHttpContext.Object, new RouteData()), mockController.Object);
+            var result = new ContentResult { Content = "blah blah" };
+            var filterContext = new ResultExecutingContext(controllerContext, result);
+
+            var filter = new ContentTypeAttribute("text/xml");
+            filter.OnResultExecuting(filterContext);
+
+            mockHttpResponse.VerifySet(r => r.ContentType = "text/xml");
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/ControllerExtensionsTest.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Web.Mvc;
+using Microsoft.Web.UnitTestUtil;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class ControllerExtensionsTest
+    {
+        private const string AppPathModifier = MvcHelper.AppPathModifier;
+
+        [Fact]
+        public void RedirectToAction_DifferentController()
+        {
+            // Act
+            RedirectToRouteResult result = new SampleController().RedirectToAction<DifferentController>(x => x.SomeOtherMethod(84));
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("", result.RouteName);
+            Assert.Equal(3, result.RouteValues.Count);
+            Assert.Equal("Different", result.RouteValues["controller"]);
+            Assert.Equal("SomeOtherMethod", result.RouteValues["action"]);
+            Assert.Equal(84, result.RouteValues["someOtherParameter"]);
+        }
+
+        [Fact]
+        public void RedirectToAction_SameController()
+        {
+            // Act
+            RedirectToRouteResult result = new SampleController().RedirectToAction(x => x.SomeMethod(42));
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal("", result.RouteName);
+            Assert.Equal(3, result.RouteValues.Count);
+            Assert.Equal("Sample", result.RouteValues["controller"]);
+            Assert.Equal("SomeMethod", result.RouteValues["action"]);
+            Assert.Equal(42, result.RouteValues["someParameter"]);
+        }
+
+        [Fact]
+        public void RedirectToAction_ThrowsIfControllerIsNull()
+        {
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { ((SampleController)null).RedirectToAction(x => x.SomeMethod(42)); }, "controller");
+        }
+
+        private class SampleController : Controller
+        {
+            public ActionResult SomeMethod(int someParameter)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        private class DifferentController : Controller
+        {
+            public ActionResult SomeOtherMethod(int someOtherParameter)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/CookieTempDataProviderTest.cs

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Web;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class CookieTempDataProviderTest
+    {
+        [Fact]
+        public void ConstructProviderThrowsOnNullHttpContext()
+        {
+            Assert.ThrowsArgumentNull(
+                delegate { new CookieTempDataProvider(null); },
+                "httpContext");
+        }
+
+        [Fact]
+        public void CtorSetsHttpContextProperty()
+        {
+            var httpContext = new Mock<HttpContextBase>().Object;
+            var provider = new CookieTempDataProvider(httpContext);
+
+            Assert.Equal(httpContext, provider.HttpContext);
+        }
+
+        [Fact]
+        public void LoadTempDataWithEmptyCookieReturnsEmptyDictionary()
+        {
+            HttpCookie cookie = new HttpCookie("__ControllerTempData");
+            cookie.Value = String.Empty;
+            var cookies = new HttpCookieCollection();
+            cookies.Add(cookie);
+
+            var requestMock = new Mock<HttpRequestBase>();
+            requestMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+
+            IDictionary<string, object> tempData = provider.LoadTempData(null /* controllerContext */);
+            Assert.NotNull(tempData);
+            Assert.Equal(0, tempData.Count);
+        }
+
+        [Fact]
+        public void LoadTempDataWithNullCookieReturnsEmptyTempDataDictionary()
+        {
+            var cookies = new HttpCookieCollection();
+
+            var requestMock = new Mock<HttpRequestBase>();
+            requestMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+
+            IDictionary<string, object> tempData = provider.LoadTempData(null /* controllerContext */);
+            Assert.NotNull(tempData);
+            Assert.Equal(0, tempData.Count);
+        }
+
+        [Fact]
+        public void LoadTempDataIgnoresNullResponseCookieDoesNotThrowException()
+        {
+            HttpCookie cookie = new HttpCookie("__ControllerTempData");
+            var initialTempData = new Dictionary<string, object>();
+            initialTempData.Add("WhatIsInHere?", "Stuff");
+            cookie.Value = CookieTempDataProvider.DictionaryToBase64String(initialTempData);
+            var cookies = new HttpCookieCollection();
+            cookies.Add(cookie);
+
+            var requestMock = new Mock<HttpRequestBase>();
+            requestMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var responseMock = new Mock<HttpResponseBase>();
+            responseMock.Setup(r => r.Cookies).Returns((HttpCookieCollection)null);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
+            httpContextMock.Setup(c => c.Response).Returns(responseMock.Object);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+
+            IDictionary<string, object> tempData = provider.LoadTempData(null /* controllerContext */);
+            Assert.Equal("Stuff", tempData["WhatIsInHere?"]);
+        }
+
+        [Fact]
+        public void LoadTempDataWithNullResponseDoesNotThrowException()
+        {
+            HttpCookie cookie = new HttpCookie("__ControllerTempData");
+            var initialTempData = new Dictionary<string, object>();
+            initialTempData.Add("WhatIsInHere?", "Stuff");
+            cookie.Value = CookieTempDataProvider.DictionaryToBase64String(initialTempData);
+            var cookies = new HttpCookieCollection();
+            cookies.Add(cookie);
+
+            var requestMock = new Mock<HttpRequestBase>();
+            requestMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
+            httpContextMock.Setup(c => c.Response).Returns((HttpResponseBase)null);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+
+            IDictionary<string, object> tempData = provider.LoadTempData(null /* controllerContext */);
+            Assert.Equal("Stuff", tempData["WhatIsInHere?"]);
+        }
+
+        [Fact]
+        public void SaveTempDataStoresSerializedFormInCookie()
+        {
+            var cookies = new HttpCookieCollection();
+            var responseMock = new Mock<HttpResponseBase>();
+            responseMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Response).Returns(responseMock.Object);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+            var tempData = new Dictionary<string, object>();
+            tempData.Add("Testing", "Turn it up to 11");
+            tempData.Add("Testing2", 1.23);
+
+            provider.SaveTempData(null, tempData);
+            HttpCookie cookie = cookies["__ControllerTempData"];
+            string serialized = cookie.Value;
+            IDictionary<string, object> deserializedTempData = CookieTempDataProvider.Base64StringToDictionary(serialized);
+            Assert.Equal("Turn it up to 11", deserializedTempData["Testing"]);
+            Assert.Equal(1.23, deserializedTempData["Testing2"]);
+        }
+
+        [Fact]
+        public void CanLoadTempDataFromCookie()
+        {
+            var tempData = new Dictionary<string, object>();
+            tempData.Add("abc", "easy as 123");
+            tempData.Add("price", 1.234);
+            string serializedTempData = CookieTempDataProvider.DictionaryToBase64String(tempData);
+
+            var cookies = new HttpCookieCollection();
+            var httpCookie = new HttpCookie("__ControllerTempData");
+            httpCookie.Value = serializedTempData;
+            cookies.Add(httpCookie);
+
+            var requestMock = new Mock<HttpRequestBase>();
+            requestMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var responseMock = new Mock<HttpResponseBase>();
+            responseMock.Setup(r => r.Cookies).Returns(cookies);
+
+            var httpContextMock = new Mock<HttpContextBase>();
+            httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
+            httpContextMock.Setup(c => c.Response).Returns(responseMock.Object);
+
+            ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
+            IDictionary<string, object> loadedTempData = provider.LoadTempData(null /* controllerContext */);
+            Assert.Equal(2, loadedTempData.Count);
+            Assert.Equal("easy as 123", loadedTempData["abc"]);
+            Assert.Equal(1.234, loadedTempData["price"]);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/CookieValueProviderFactoryTest.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Globalization;
+using System.Web;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class CookieValueProviderFactoryTest
+    {
+        [Fact]
+        public void GetValueProvider()
+        {
+            // Arrange
+            HttpCookieCollection cookies = new HttpCookieCollection
+            {
+                new HttpCookie("foo", "fooValue"),
+                new HttpCookie("bar.baz", "barBazValue"),
+                new HttpCookie("", "emptyValue"),
+                new HttpCookie(null, "nullValue")
+            };
+
+            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
+            mockControllerContext.Setup(o => o.HttpContext.Request.Cookies).Returns(cookies);
+
+            CookieValueProviderFactory factory = new CookieValueProviderFactory();
+
+            // Act
+            IValueProvider provider = factory.GetValueProvider(mockControllerContext.Object);
+
+            // Assert
+            Assert.Null(provider.GetValue(""));
+            Assert.True(provider.ContainsPrefix("bar"));
+            Assert.Equal("fooValue", provider.GetValue("foo").AttemptedValue);
+            Assert.Equal(CultureInfo.InvariantCulture, provider.GetValue("foo").Culture);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/CopyAsyncParametersAttributeTest.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Web.Mvc;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class CopyAsyncParametersAttributeTest
+    {
+        [Fact]
+        public void OnActionExecuting_CopiesParametersIfControllerIsAsync()
+        {
+            // Arrange
+            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();
+            SampleAsyncController controller = new SampleAsyncController();
+
+            ActionExecutingContext filterContext = new ActionExecutingContext
+            {
+                ActionParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase),
+                Controller = controller
+            };
+            filterContext.ActionParameters["foo"] = "fooAction";
+            filterContext.ActionParameters["bar"] = "barAction";
+            controller.AsyncManager.Parameters["bar"] = "barAsync";
+            controller.AsyncManager.Parameters["baz"] = "bazAsync";
+
+            // Act
+            attr.OnActionExecuting(filterContext);
+
+            // Assert
+            Assert.Equal("fooAction", controller.AsyncManager.Parameters["foo"]);
+            Assert.Equal("barAction", controller.AsyncManager.Parameters["bar"]);
+            Assert.Equal("bazAsync", controller.AsyncManager.Parameters["baz"]);
+        }
+
+        [Fact]
+        public void OnActionExecuting_DoesNothingIfControllerNotAsync()
+        {
+            // Arrange
+            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();
+            SampleSyncController controller = new SampleSyncController();
+
+            ActionExecutingContext filterContext = new ActionExecutingContext
+            {
+                ActionParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase),
+                Controller = controller
+            };
+            filterContext.ActionParameters["foo"] = "originalFoo";
+            filterContext.ActionParameters["bar"] = "originalBar";
+
+            // Act
+            attr.OnActionExecuting(filterContext);
+
+            // Assert
+            // If we got this far without crashing, life is good :)
+        }
+
+        [Fact]
+        public void OnActionExecuting_ThrowsIfFilterContextIsNull()
+        {
+            // Arrange
+            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();
+
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { attr.OnActionExecuting(null); }, "filterContext");
+        }
+
+        private class SampleSyncController : Controller
+        {
+        }
+
+        private class SampleAsyncController : AsyncController
+        {
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/CreditCardAttributeTest.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Linq;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class CreditCardAttributeTest
+    {
+        [Fact]
+        public void ClientRule()
+        {
+            // Arrange
+            var attribute = new CreditCardAttribute();
+            var provider = new Mock<ModelMetadataProvider>();
+            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");
+
+            // Act
+            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();
+
+            // Assert
+            Assert.Equal("creditcard", clientRule.ValidationType);
+            Assert.Equal("The PropertyName field is not a valid credit card number.", clientRule.ErrorMessage);
+            Assert.Empty(clientRule.ValidationParameters);
+        }
+
+        [Fact]
+        public void IsValidTests()
+        {
+            // Arrange
+            var attribute = new CreditCardAttribute();
+
+            // Act & Assert
+            Assert.True(attribute.IsValid(null)); // Optional values are always valid
+            Assert.True(attribute.IsValid("0000000000000000")); // Simplest valid value
+            Assert.True(attribute.IsValid("1234567890123452")); // Good checksum
+            Assert.True(attribute.IsValid("1234-5678-9012-3452")); // Good checksum, with dashes
+            Assert.False(attribute.IsValid("0000000000000001")); // Bad checksum
+            Assert.False(attribute.IsValid(0)); // Non-string
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/CssExtensionsTests.cs

@@ -0,0 +1,140 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Web.Mvc;
+using Microsoft.Web.UnitTestUtil;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class CssExtensionsTests
+    {
+        [Fact]
+        public void CssWithoutFileThrowsArgumentNullException()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Assert
+            Assert.ThrowsArgumentNullOrEmpty(() => html.Css(null), "file");
+        }
+
+        [Fact]
+        public void CssWithRootedPathRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("~/Correct/Path.css");
+
+            // Assert
+            Assert.Equal("<link href=\"/$(SESSION)/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithRelativePathRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("../../Correct/Path.css");
+
+            // Assert
+            Assert.Equal("<link href=\"../../Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithRelativeCurrentPathRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("/Correct/Path.css");
+
+            // Assert
+            Assert.Equal("<link href=\"/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithContentRelativePathRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("Correct/Path.css");
+
+            // Assert
+            Assert.Equal("<link href=\"/$(SESSION)/Content/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithNullMediaTypeRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("Correct/Path.css", null);
+
+            // Assert
+            Assert.Equal("<link href=\"/$(SESSION)/Content/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithEmptyMediaTypeRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("Correct/Path.css", String.Empty);
+
+            // Assert
+            Assert.Equal("<link href=\"/$(SESSION)/Content/Correct/Path.css\" media=\"\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithMediaTypeRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("Correct/Path.css", "Print");
+
+            // Assert
+            Assert.Equal("<link href=\"/$(SESSION)/Content/Correct/Path.css\" media=\"Print\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithUrlRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("http://ajax.Correct.com/Path.js");
+
+            // Assert
+            Assert.Equal("<link href=\"http://ajax.Correct.com/Path.js\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+
+        [Fact]
+        public void CssWithSecureUrlRendersProperElement()
+        {
+            // Arrange
+            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
+
+            // Act
+            MvcHtmlString result = html.Css("https://ajax.Correct.com/Path.js");
+
+            // Assert
+            Assert.Equal("<link href=\"https://ajax.Correct.com/Path.js\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/DeserializeAttributeTest.cs

@@ -0,0 +1,107 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Runtime.Serialization;
+using System.Web.Mvc;
+using Microsoft.Web.UnitTestUtil;
+using Moq;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class DeserializeAttributeTest
+    {
+        [Fact]
+        public void BinderReturnsDeserializedValue()
+        {
+            // Arrange
+            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
+            mockSerializer.Setup(o => o.Deserialize("some-value", SerializationMode.EncryptedAndSigned)).Returns(42);
+            DeserializeAttribute attr = new DeserializeAttribute(SerializationMode.EncryptedAndSigned) { Serializer = mockSerializer.Object };
+
+            IModelBinder binder = attr.GetBinder();
+            ModelBindingContext mbContext = new ModelBindingContext
+            {
+                ModelName = "someKey",
+                ValueProvider = new SimpleValueProvider
+                {
+                    { "someKey", "some-value" }
+                }
+            };
+
+            // Act
+            object retVal = binder.BindModel(null, mbContext);
+
+            // Assert
+            Assert.Equal(42, retVal);
+        }
+
+        [Fact]
+        public void BinderReturnsNullIfValueProviderDoesNotContainKey()
+        {
+            // Arrange
+            DeserializeAttribute attr = new DeserializeAttribute();
+            IModelBinder binder = attr.GetBinder();
+            ModelBindingContext mbContext = new ModelBindingContext
+            {
+                ModelName = "someKey",
+                ValueProvider = new SimpleValueProvider()
+            };
+
+            // Act
+            object retVal = binder.BindModel(null, mbContext);
+
+            // Assert
+            Assert.Null(retVal);
+        }
+
+        [Fact]
+        public void BinderThrowsIfBindingContextIsNull()
+        {
+            // Arrange
+            DeserializeAttribute attr = new DeserializeAttribute();
+            IModelBinder binder = attr.GetBinder();
+
+            // Act & assert
+            Assert.ThrowsArgumentNull(
+                delegate { binder.BindModel(null, null); }, "bindingContext");
+        }
+
+        [Fact]
+        public void BinderThrowsIfDataCorrupt()
+        {
+            // Arrange
+            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
+            mockSerializer.Setup(o => o.Deserialize(It.IsAny<string>(), It.IsAny<SerializationMode>())).Throws(new SerializationException());
+            DeserializeAttribute attr = new DeserializeAttribute { Serializer = mockSerializer.Object };
+
+            IModelBinder binder = attr.GetBinder();
+            ModelBindingContext mbContext = new ModelBindingContext
+            {
+                ModelName = "someKey",
+                ValueProvider = new SimpleValueProvider
+                {
+                    { "someKey", "This data is corrupted." }
+                }
+            };
+
+            // Act & assert
+            Exception exception = Assert.Throws<SerializationException>(
+                delegate { binder.BindModel(null, mbContext); });
+        }
+
+        [Fact]
+        public void ModeDefaultsToSigned()
+        {
+            // Arrange
+            DeserializeAttribute attr = new DeserializeAttribute();
+
+            // Act
+            SerializationMode defaultMode = attr.Mode;
+
+            // Assert
+            Assert.Equal(SerializationMode.Signed, defaultMode);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/DynamicReflectionObjectTest.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class DynamicReflectionObjectTest
+    {
+        [Fact]
+        public void NoPropertiesThrows()
+        {
+            // Arrange
+            dynamic dro = DynamicReflectionObject.Wrap(new { });
+
+            // Act & Assert
+            Assert.Throws<InvalidOperationException>(
+                () => dro.baz,
+                "The property baz doesn't exist. There are no public properties on this object.");
+        }
+
+        [Fact]
+        public void UnknownPropertyThrows()
+        {
+            // Arrange
+            dynamic dro = DynamicReflectionObject.Wrap(new { foo = 3.4, biff = "Two", bar = 1 });
+
+            // Act & Assert
+            Assert.Throws<InvalidOperationException>(
+                () => dro.baz,
+                "The property baz doesn't exist. Supported properties are: bar, biff, foo.");
+        }
+
+        [Fact]
+        public void CanAccessProperties()
+        {
+            // Arrange
+            dynamic dro = DynamicReflectionObject.Wrap(new { foo = "Hello world!", bar = 42 });
+
+            // Act & Assert
+            Assert.Equal("Hello world!", dro.foo);
+            Assert.Equal(42, dro.bar);
+        }
+
+        [Fact]
+        public void CanAccessNestedAnonymousProperties()
+        {
+            // Arrange
+            dynamic dro = DynamicReflectionObject.Wrap(new { foo = new { bar = "Hello world!" } });
+
+            // Act & Assert
+            Assert.Equal("Hello world!", dro.foo.bar);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/DynamicViewDataDictionaryTest.cs

@@ -0,0 +1,117 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Web.Mvc;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class DynamicViewDataDictionaryTest
+    {
+        // Property-style accessor
+
+        [Fact]
+        public void Property_UnknownItemReturnsEmptyString()
+        {
+            // Arrange
+            ViewDataDictionary vdd = new ViewDataDictionary();
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd.Foo;
+
+            // Assert
+            Assert.Equal(String.Empty, result);
+        }
+
+        [Fact]
+        public void Property_CanAccessViewDataValues()
+        {
+            // Arrange
+            ViewDataDictionary vdd = new ViewDataDictionary();
+            vdd["Foo"] = "Value for Foo";
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd.Foo;
+
+            // Assert
+            Assert.Equal("Value for Foo", result);
+        }
+
+        [Fact]
+        public void Property_CanAccessModelProperties()
+        {
+            ViewDataDictionary vdd = new ViewDataDictionary(new { Foo = "Value for Foo" });
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd.Foo;
+
+            // Assert
+            Assert.Equal("Value for Foo", result);
+        }
+
+        // Index-style accessor
+
+        [Fact]
+        public void Indexer_GuardClauses()
+        {
+            // Arrange
+            ViewDataDictionary vdd = new ViewDataDictionary();
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act & Assert
+            Assert.Throws<ArgumentException>(
+                () => { var x = dvdd["foo", "bar"]; },
+                "DynamicViewDataDictionary only supports single indexers.");
+
+            Assert.Throws<ArgumentException>(
+                () => { var x = dvdd[42]; },
+                "DynamicViewDataDictionary only supports string-based indexers.");
+        }
+
+        [Fact]
+        public void Indexer_UnknownItemReturnsEmptyString()
+        {
+            // Arrange
+            ViewDataDictionary vdd = new ViewDataDictionary();
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd["Foo"];
+
+            // Assert
+            Assert.Equal(String.Empty, result);
+        }
+
+        [Fact]
+        public void Indexer_CanAccessViewDataValues()
+        {
+            // Arrange
+            ViewDataDictionary vdd = new ViewDataDictionary();
+            vdd["Foo"] = "Value for Foo";
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd["Foo"];
+
+            // Assert
+            Assert.Equal("Value for Foo", result);
+        }
+
+        [Fact]
+        public void Indexer_CanAccessModelProperties()
+        {
+            ViewDataDictionary vdd = new ViewDataDictionary(new { Foo = "Value for Foo" });
+            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);
+
+            // Act
+            object result = dvdd["Foo"];
+
+            // Assert
+            Assert.Equal("Value for Foo", result);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/DynamicViewPageTest.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class DynamicViewPageTest
+    {
+        // DynamicViewPage
+
+        [Fact]
+        public void AnonymousObjectsAreWrapped()
+        {
+            // Arrange
+            DynamicViewPage page = new DynamicViewPage();
+            page.ViewData.Model = new { foo = "Hello world!" };
+
+            // Act & Assert
+            Assert.Equal("Microsoft.Web.Mvc.DynamicReflectionObject", page.Model.GetType().FullName);
+        }
+
+        [Fact]
+        public void NonAnonymousObjectsAreNotWrapped()
+        {
+            // Arrange
+            DynamicViewPage page = new DynamicViewPage();
+            page.ViewData.Model = "Hello world!";
+
+            // Act & Assert
+            Assert.Equal(typeof(string), page.Model.GetType());
+        }
+
+        [Fact]
+        public void ViewDataDictionaryIsWrapped()
+        {
+            // Arrange
+            DynamicViewPage page = new DynamicViewPage();
+
+            // Act & Assert
+            Assert.Equal("Microsoft.Web.Mvc.DynamicViewDataDictionary", page.ViewData.GetType().FullName);
+        }
+
+        // DynamicViewPage<T>
+
+        [Fact]
+        public void Generic_ViewDataDictionaryIsWrapped()
+        {
+            // Arrange
+            DynamicViewPage<object> page = new DynamicViewPage<object>();
+
+            // Act & Assert
+            Assert.Equal("Microsoft.Web.Mvc.DynamicViewDataDictionary", page.ViewData.GetType().FullName);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/ElementalValueProviderTest.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Globalization;
+using System.Web.Mvc;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class ElementalValueProviderTest
+    {
+        [Fact]
+        public void ContainsPrefix()
+        {
+            // Arrange
+            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", 42, null);
+
+            // Act & assert
+            Assert.True(valueProvider.ContainsPrefix("foo"));
+            Assert.False(valueProvider.ContainsPrefix("bar"));
+        }
+
+        [Fact]
+        public void GetValue_NameDoesNotMatch_ReturnsNull()
+        {
+            // Arrange
+            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
+            DateTime rawValue = new DateTime(2001, 1, 2);
+            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);
+
+            // Act
+            ValueProviderResult vpResult = valueProvider.GetValue("bar");
+
+            // Assert
+            Assert.Null(vpResult);
+        }
+
+        [Fact]
+        public void GetValue_NameMatches_ReturnsValueProviderResult()
+        {
+            // Arrange
+            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
+            DateTime rawValue = new DateTime(2001, 1, 2);
+            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);
+
+            // Act
+            ValueProviderResult vpResult = valueProvider.GetValue("FOO");
+
+            // Assert
+            Assert.NotNull(vpResult);
+            Assert.Equal(rawValue, vpResult.RawValue);
+            Assert.Equal("02/01/2001 00:00:00", vpResult.AttemptedValue);
+            Assert.Equal(culture, vpResult.Culture);
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/EmailAddressAttribueTest.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Linq;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class EmailAddressAttribueTest
+    {
+        [Fact]
+        public void ClientRule()
+        {
+            // Arrange
+            var attribute = new EmailAddressAttribute();
+            var provider = new Mock<ModelMetadataProvider>();
+            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");
+
+            // Act
+            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();
+
+            // Assert
+            Assert.Equal("email", clientRule.ValidationType);
+            Assert.Equal("The PropertyName field is not a valid e-mail address.", clientRule.ErrorMessage);
+            Assert.Empty(clientRule.ValidationParameters);
+        }
+
+        [Fact]
+        public void IsValidTests()
+        {
+            // Arrange
+            var attribute = new EmailAddressAttribute();
+
+            // Act & Assert
+            Assert.True(attribute.IsValid(null)); // Optional values are always valid
+            Assert.True(attribute.IsValid("joe@contoso.com"));
+            Assert.True(attribute.IsValid("joe%fred@contoso.com"));
+            Assert.False(attribute.IsValid("joe"));
+            Assert.False(attribute.IsValid("joe@"));
+            Assert.False(attribute.IsValid("joe@contoso"));
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/ExpressionHelperTest.cs

@@ -0,0 +1,304 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Linq.Expressions;
+using System.Web.Mvc;
+using System.Web.Routing;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class ExpressionHelperTest
+    {
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsAsynchronousAsyncMethod_StripsSuffix()
+        {
+            // Arrange
+            Expression<Action<TestAsyncController>> expr = (c => c.AsynchronousAsync());
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
+
+            // Assert
+            Assert.Equal("Asynchronous", rvd["action"]);
+            Assert.Equal("TestAsync", rvd["controller"]);
+            Assert.False(rvd.ContainsKey("area"));
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsAsynchronousCompletedMethod_Throws()
+        {
+            // Arrange
+            Expression<Action<TestAsyncController>> expr = (c => c.AsynchronousCompleted());
+
+            // Act & assert
+            Assert.Throws<InvalidOperationException>(
+                delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
+                @"The method 'AsynchronousCompleted' is an asynchronous completion method and cannot be called directly.");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsControllerWithAreaAttribute_AddsAreaName()
+        {
+            // Arrange
+            Expression<Action<ControllerWithAreaController>> expr = c => c.Index();
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
+
+            // Assert
+            Assert.Equal("Index", rvd["action"]);
+            Assert.Equal("ControllerWithArea", rvd["controller"]);
+            Assert.Equal("the area name", rvd["area"]);
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsNonActionMethod_Throws()
+        {
+            // Arrange
+            Expression<Action<TestController>> expr = (c => c.NotAnAction());
+
+            // Act & assert
+            Assert.Throws<InvalidOperationException>(
+                delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
+                @"The method 'NotAnAction' is marked [NonAction] and cannot be called directly.");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsRenamedMethod_UsesNewName()
+        {
+            // Arrange
+            Expression<Action<TestController>> expr = (c => c.Renamed());
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
+
+            // Assert
+            Assert.Equal("NewName", rvd["action"]);
+            Assert.Equal("Test", rvd["controller"]);
+            Assert.False(rvd.ContainsKey("area"));
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionary_TargetsSynchronousMethodOnAsyncController_ReturnsOriginalName()
+        {
+            // Arrange
+            Expression<Action<TestAsyncController>> expr = (c => c.Synchronous());
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);
+
+            // Assert
+            Assert.Equal("Synchronous", rvd["action"]);
+            Assert.Equal("TestAsync", rvd["controller"]);
+            Assert.False(rvd.ContainsKey("area"));
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryWithNullExpressionThrowsArgumentNullException()
+        {
+            Assert.ThrowsArgumentNull(
+                () => ExpressionHelper.GetRouteValuesFromExpression<TestController>(null),
+                "action");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryWithNonMethodExpressionThrowsInvalidOperationException()
+        {
+            // Arrange
+            Expression<Action<TestController>> expression = c => new TestController();
+
+            // Act & Assert
+            Assert.Throws<ArgumentException>(
+                () => ExpressionHelper.GetRouteValuesFromExpression(expression),
+                "Expression must be a method call." + Environment.NewLine + "Parameter name: action");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryWithoutControllerSuffixThrowsInvalidOperationException()
+        {
+            // Arrange
+            Expression<Action<TestControllerNot>> index = (c => c.Index(123));
+
+            // Act & Assert
+            Assert.Throws<ArgumentException>(
+                () => ExpressionHelper.GetRouteValuesFromExpression(index),
+                "Controller name must end in 'Controller'." + Environment.NewLine + "Parameter name: action");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryWithControllerBaseClassThrowsInvalidOperationException()
+        {
+            // Arrange
+            Expression<Action<Controller>> index = (c => c.Dispose());
+
+            // Act & Assert
+            Assert.Throws<ArgumentException>(
+                () => ExpressionHelper.GetRouteValuesFromExpression(index),
+                "Cannot route to class named 'Controller'." + Environment.NewLine + "Parameter name: action");
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryAddsControllerNameToDictionary()
+        {
+            // Arrange
+            Expression<Action<TestController>> index = (c => c.Index(123));
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
+
+            // Assert
+            Assert.Equal("Test", rvd["Controller"]);
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryFromExpressionReturnsCorrectDictionary()
+        {
+            // Arrange
+            Expression<Action<TestController>> index = (c => c.Index(123));
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
+
+            // Assert
+            Assert.Equal("Test", rvd["Controller"]);
+            Assert.Equal("Index", rvd["Action"]);
+            Assert.Equal(123, rvd["page"]);
+        }
+
+        [Fact]
+        public void BuildRouteValueDictionaryFromNonConstantExpressionReturnsCorrectDictionary()
+        {
+            // Arrange
+            Expression<Action<TestController>> index = (c => c.About(Foo));
+
+            // Act
+            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);
+
+            // Assert
+            Assert.Equal("Test", rvd["Controller"]);
+            Assert.Equal("About", rvd["Action"]);
+            Assert.Equal("FooValue", rvd["s"]);
+        }
+
+        [Fact]
+        public void GetInputNameFromPropertyExpressionReturnsPropertyName()
+        {
+            // Arrange
+            Expression<Func<TestModel, int>> expression = m => m.IntProperty;
+
+            // Act
+            string name = ExpressionHelper.GetInputName(expression);
+
+            // Assert
+            Assert.Equal("IntProperty", name);
+        }
+
+        [Fact]
+        public void GetInputNameFromPropertyWithMethodCallExpressionReturnsPropertyName()
+        {
+            // Arrange
+            Expression<Func<TestModel, string>> expression = m => m.IntProperty.ToString();
+
+            // Act
+            string name = ExpressionHelper.GetInputName(expression);
+
+            // Assert
+            Assert.Equal("IntProperty", name);
+        }
+
+        [Fact]
+        public void GetInputNameFromPropertyWithTwoMethodCallExpressionReturnsPropertyName()
+        {
+            // Arrange
+            Expression<Func<TestModel, string>> expression = m => m.IntProperty.ToString().ToUpper();
+
+            // Act
+            string name = ExpressionHelper.GetInputName(expression);
+
+            // Assert
+            Assert.Equal("IntProperty", name);
+        }
+
+        [Fact]
+        public void GetInputNameFromExpressionWithTwoPropertiesUsesWholeExpression()
+        {
+            // Arrange
+            Expression<Func<TestModel, int>> expression = m => m.StringProperty.Length;
+
+            // Act
+            string name = ExpressionHelper.GetInputName(expression);
+
+            // Assert
+            Assert.Equal("StringProperty.Length", name);
+        }
+
+        public class TestController : Controller
+        {
+            public ActionResult Index(int page)
+            {
+                return null;
+            }
+
+            public string About(string s)
+            {
+                return "The value is " + s;
+            }
+
+            [ActionName("NewName")]
+            public void Renamed()
+            {
+            }
+
+            [NonAction]
+            public void NotAnAction()
+            {
+            }
+        }
+
+        public class TestAsyncController : AsyncController
+        {
+            public void Synchronous()
+            {
+            }
+
+            public void AsynchronousAsync()
+            {
+            }
+
+            public void AsynchronousCompleted()
+            {
+            }
+        }
+
+        public string Foo
+        {
+            get { return "FooValue"; }
+        }
+
+        public class TestControllerNot : Controller
+        {
+            public ActionResult Index(int page)
+            {
+                return null;
+            }
+        }
+
+        [ActionLinkArea("the area name")]
+        public class ControllerWithAreaController : Controller
+        {
+            public ActionResult Index()
+            {
+                return null;
+            }
+        }
+
+        public class TestModel
+        {
+            public int IntProperty { get; set; }
+            public string StringProperty { get; set; }
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/FileExtensionsAttributeTest.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Linq;
+using System.Web.Mvc;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class FileExtensionsAttributeTest
+    {
+        [Fact]
+        public void DefaultExtensions()
+        {
+            Assert.Equal("png,jpg,jpeg,gif", new FileExtensionsAttribute().Extensions);
+        }
+
+        [Fact]
+        public void ClientRule()
+        {
+            // Arrange
+            var attribute = new FileExtensionsAttribute { Extensions = " FoO, .bar,baz " };
+            var provider = new Mock<ModelMetadataProvider>();
+            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");
+
+            // Act
+            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();
+
+            // Assert
+            Assert.Equal("accept", clientRule.ValidationType);
+            Assert.Equal("The PropertyName field only accepts files with the following extensions: .foo, .bar, .baz", clientRule.ErrorMessage);
+            Assert.Single(clientRule.ValidationParameters);
+            Assert.Equal("foo,bar,baz", clientRule.ValidationParameters["exts"]);
+        }
+
+        [Fact]
+        public void IsValidTests()
+        {
+            // Arrange
+            var attribute = new FileExtensionsAttribute();
+
+            // Act & Assert
+            Assert.True(attribute.IsValid(null)); // Optional values are always valid
+            Assert.True(attribute.IsValid("foo.png"));
+            Assert.True(attribute.IsValid("foo.jpeg"));
+            Assert.True(attribute.IsValid("foo.jpg"));
+            Assert.True(attribute.IsValid("foo.gif"));
+            Assert.True(attribute.IsValid(@"C:\Foo\baz.jpg"));
+            Assert.False(attribute.IsValid("foo"));
+            Assert.False(attribute.IsValid("foo.png.pif"));
+            Assert.False(attribute.IsValid(@"C:\foo.png\bar"));
+            Assert.False(attribute.IsValid("\0foo.png")); // Illegal character
+        }
+    }
+}

external/aspnetwebstack/test/Microsoft.Web.Mvc.Test/Test/FormExtensionsTest.cs

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+using System.Web;
+using System.Web.Mvc;
+using System.Web.Routing;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Web.Mvc.Test
+{
+    public class FormExtensionsTest
+    {
+        internal const string AppPathModifier = "/$(SESSION)";
+
+        [Fact]
+        public void FormWithPostAction()
+        {
+            // Arrange
+            StringWriter writer;
+            HtmlHelper htmlHelper = GetFormHelper(out writer);
+
+            // Act
+            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About());
+            formDisposable.Dispose();
+
+            // Assert
+            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" method=""post""></form>", writer.ToString());
+        }
+
+        [Fact]
+        public void FormWithPostActionAndObjectAttributes()
+        {
+            // Arrange
+            StringWriter writer;
+            HtmlHelper htmlHelper = GetFormHelper(out writer);
+
+            // Act
+            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About(), FormMethod.Get, new { baz = "baz" });
+            formDisposable.Dispose();
+
+            // Assert
+            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" baz=""baz"" method=""get""></form>", writer.ToString());
+        }
+
+        [Fact]
+        public void FormWithPostActionAndObjectAttributesWithUnderscores()
+        {
+            // Arrange
+            StringWriter writer;
+            HtmlHelper htmlHelper = GetFormHelper(out writer);
+
+            // Act
+            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About(), FormMethod.Get, new { foo_baz = "baz" });
+            formDisposable.Dispose();
+
+            // Assert
+            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" foo-baz=""baz"" method=""get""></form>", writer.ToString());
+        }
+
+        public class FormController : Controller
+        {
+            public ActionResult About()
+            {
+                return RedirectToAction("foo");
+            }
+        }
+
+        private static HtmlHelper GetFormHelper(out StringWriter writer)
+        {
+            Mock<HttpRequestBase> mockHttpRequest = new Mock<HttpRequestBase>();
+            mockHttpRequest.Setup(r => r.Url).Returns(new Uri("http://www.contoso.com/some/path"));
+            Mock<HttpResponseBase> mockHttpResponse = new Mock<HttpResponseBase>(MockBehavior.Strict);
+
+            mockHttpResponse.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => AppPathModifier + r);
+            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
+            mockHttpContext.Setup(c => c.Request).Returns(mockHttpRequest.Object);
+            mockHttpContext.Setup(c => c.Response).Returns(mockHttpResponse.Object);
+            RouteCollection rt = new RouteCollection();
+            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
+            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
+            RouteData rd = new RouteData();
+            rd.Values.Add("controller", "home");
+            rd.Values.Add("action", "oldaction");
+
+            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
+            mockViewContext.Setup(c => c.HttpContext).Returns(mockHttpContext.Object);
+            mockViewContext.Setup(c => c.RouteData).Returns(rd);
+            writer = new StringWriter();
+            mockViewContext.Setup(c => c.Writer).Returns(writer);
+
+            HtmlHelper helper = new HtmlHelper(
+                mockViewContext.Object,
+                new Mock<IViewDataContainer>().Object,
+                rt);
+            return helper;
+        }
+    }
+}