/test/System.Web.Mvc.Test/Html/Test/TemplateHelpersTest.cs

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using System.Web.Routing;
using System.Web.UI.WebControls;
using Microsoft.Web.UnitTestUtil;
using Moq;
using Xunit;
using Assert = Microsoft.TestCommon.AssertEx;

namespace System.Web.Mvc.Html.Test
{
    public class TemplateHelpersTest
    {
        // ExecuteTemplate

        private class ExecuteTemplateModel
        {
            public string MyProperty { get; set; }
            public Nullable<int> MyNullableProperty { get; set; }
        }

        [Fact]
        public void ExecuteTemplateCallsGetViewNamesWithProvidedTemplateNameAndMetadataInformation()
        {
            using (new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel());
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                metadata.TemplateHint = "templateHint";
                metadata.DataTypeName = "dataType";
                string[] hints = null;

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, MakeViewData(html, metadata), "templateName", DataBoundControlMode.ReadOnly,
                    (_metadata, _hints) =>
                    {
                        hints = _hints;
                        return new[] { "String" };
                    },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                Assert.NotNull(hints);
                Assert.Equal(3, hints.Length);
                Assert.Equal("templateName", hints[0]);
                Assert.Equal("templateHint", hints[1]);
                Assert.Equal("dataType", hints[2]);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromViewEngineInReadOnlyMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewContext callbackViewContext = null;
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "DisplayTemplates/String", true))
                    .Returns(new ViewEngineResult(engine.View.Object, engine.Engine.Object))
                    .Verifiable();
                engine.View.Setup(v => v.Render(It.IsAny<ViewContext>(), It.IsAny<TextWriter>()))
                    .Callback<ViewContext, TextWriter>((vc, tw) =>
                    {
                        callbackViewContext = vc;
                        tw.Write("View Text");
                    })
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.ReadOnly,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.View.Verify();
                Assert.Equal("View Text", result);
                Assert.Same(engine.View.Object, callbackViewContext.View);
                Assert.Same(viewData, callbackViewContext.ViewData);
                Assert.Same(html.ViewContext.TempData, callbackViewContext.TempData);
                TemplateHelpers.ActionCacheViewItem cacheItem = TemplateHelpers.GetActionCache(html)["DisplayTemplates/String"] as TemplateHelpers.ActionCacheViewItem;
                Assert.NotNull(cacheItem);
                Assert.Equal("DisplayTemplates/String", cacheItem.ViewName);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromViewEngineInEditMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewContext callbackViewContext = null;
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "EditorTemplates/String", true))
                    .Returns(new ViewEngineResult(engine.View.Object, engine.Engine.Object))
                    .Verifiable();
                engine.View.Setup(v => v.Render(It.IsAny<ViewContext>(), It.IsAny<TextWriter>()))
                    .Callback<ViewContext, TextWriter>((vc, tw) =>
                    {
                        callbackViewContext = vc;
                        tw.Write("View Text");
                    })
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.View.Verify();
                Assert.Equal("View Text", result);
                Assert.Same(engine.View.Object, callbackViewContext.View);
                Assert.Same(viewData, callbackViewContext.ViewData);
                Assert.Same(html.ViewContext.TempData, callbackViewContext.TempData);
                TemplateHelpers.ActionCacheViewItem cacheItem = TemplateHelpers.GetActionCache(html)["EditorTemplates/String"] as TemplateHelpers.ActionCacheViewItem;
                Assert.NotNull(cacheItem);
                Assert.Equal("EditorTemplates/String", cacheItem.ViewName);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromDefaultActionsInReadOnlyMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "DisplayTemplates/String", It.IsAny<bool>()))
                    .Returns(new ViewEngineResult(new string[0]))
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.ReadOnly,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                TemplateHelpers.ActionCacheCodeItem cacheItem = TemplateHelpers.GetActionCache(html)["DisplayTemplates/String"] as TemplateHelpers.ActionCacheCodeItem;
                Assert.NotNull(cacheItem);
                Assert.Equal(DefaultDisplayTemplates.StringTemplate, cacheItem.Action);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromDefaultActionsInEditMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "EditorTemplates/String", It.IsAny<bool>()))
                    .Returns(new ViewEngineResult(new string[0]))
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                TemplateHelpers.ActionCacheCodeItem cacheItem = TemplateHelpers.GetActionCache(html)["EditorTemplates/String"] as TemplateHelpers.ActionCacheCodeItem;
                Assert.NotNull(cacheItem);
                Assert.Equal(DefaultEditorTemplates.StringTemplate, cacheItem.Action);
            }
        }

        [Fact]
        public void ExecuteTemplatePrefersExistingActionCacheItem()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                TemplateHelpers.GetActionCache(html).Add("EditorTemplates/String",
                                                         new TemplateHelpers.ActionCacheCodeItem { Action = _ => "Action Text" });

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.Engine.Verify(e => e.FindPartialView(It.IsAny<ControllerContext>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never());
                Assert.Equal("Action Text", result);
            }
        }

        [Fact]
        public void ExecuteTemplateThrowsWhenNoTemplatesMatch()
        {
            using (new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => TemplateHelpers.ExecuteTemplate(html, viewData, "templateName", DataBoundControlMode.Edit, delegate { return new string[0]; }, TemplateHelpers.GetDefaultActions),
                    "Unable to locate an appropriate template for type System.String.");
            }
        }

        [Fact]
        public void ExecuteTemplateCreatesNewHtmlHelperWithCorrectViewDataForDefaultAction()
        {
            using (MockViewEngine engine = new MockViewEngine(false))
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                HtmlHelper passedHtmlHelper = null;

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    delegate
                    {
                        return new Dictionary<string, Func<HtmlHelper, string>>
                        {
                            {
                                "String", _htmlHelper =>
                                {
                                    passedHtmlHelper = _htmlHelper;
                                    return "content";
                                }
                                }
                        };
                    });

                // Assert
                Assert.NotNull(passedHtmlHelper);
                Assert.Same(passedHtmlHelper.ViewData, passedHtmlHelper.ViewContext.ViewData);
                Assert.NotSame(html.ViewData, passedHtmlHelper.ViewData);
            }
        }

        [Fact]
        public void ExecuteTemplateCreatesNewHtmlHelperWithCorrectViewDataForCachedAction()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                HtmlHelper passedHtmlHelper = null;
                TemplateHelpers.GetActionCache(html).Add(
                    "EditorTemplates/String",
                    new TemplateHelpers.ActionCacheCodeItem
                    {
                        Action = _htmlHelper =>
                        {
                            passedHtmlHelper = _htmlHelper;
                            return "content";
                        }
                    });

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                Assert.NotNull(passedHtmlHelper);
                Assert.Same(passedHtmlHelper.ViewData, passedHtmlHelper.ViewContext.ViewData);
                Assert.NotSame(html.ViewData, passedHtmlHelper.ViewData);
            }
        }

        // GetActionCache

        [Fact]
        public void CacheIsCreatedIfNotPresent()
        {
            // Arrange
            Hashtable items = new Hashtable();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(items);
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.HttpContext).Returns(context.Object);
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            HtmlHelper helper = new HtmlHelper(viewContext.Object, viewDataContainer.Object);

            // Act
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache = TemplateHelpers.GetActionCache(helper);

            // Assert
            Assert.NotNull(cache);
            Assert.Empty(cache);
            Assert.Contains((object)cache, items.Values.OfType<object>());
        }

        [Fact]
        public void CacheIsReusedIfPresent()
        {
            // Arrange
            Hashtable items = new Hashtable();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(items);
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.HttpContext).Returns(context.Object);
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            HtmlHelper helper = new HtmlHelper(viewContext.Object, viewDataContainer.Object);

            // Act
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache1 = TemplateHelpers.GetActionCache(helper);
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache2 = TemplateHelpers.GetActionCache(helper);

            // Assert
            Assert.NotNull(cache1);
            Assert.Same(cache1, cache2);
        }

        // GetViewNames

        [Fact]
        public void GetViewNamesFullOrderingOfBuiltInValueType()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(double));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(4, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("Double", result[2]);
            Assert.Equal("String", result[3]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfComplexType()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(HttpWebRequest));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(6, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("HttpWebRequest", result[2]);
            Assert.Equal("WebRequest", result[3]);
            Assert.Equal("MarshalByRefObject", result[4]);
            Assert.Equal("Object", result[5]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfInterface()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDisposable));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(4, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("IDisposable", result[2]);
            Assert.Equal("Object", result[3]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfComplexTypeThatImplementsIEnumerable()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(List<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("List`1", result[2]);
            Assert.Equal("Collection", result[3]);
            Assert.Equal("Object", result[4]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfInterfaceThatRequiresIEnumerable()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IList<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("IList`1", result[2]);
            Assert.Equal("Collection", result[3]);
            Assert.Equal("Object", result[4]);
        }

        [Fact]
        public void GetViewNamesNullUIHintNotIncludedInList()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Object));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, null, "DataType").ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("DataType", result[0]);
            Assert.Equal("Object", result[1]);
        }

        [Fact]
        public void GetViewNamesNullDataTypeNotIncludedInList()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Object));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", null).ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("Object", result[1]);
        }

        [Fact]
        public void GetViewNamesConvertsNullableOfTIntoT()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Nullable<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, null, null).ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("Int32", result[0]);
            Assert.Equal("String", result[1]);
        }

        // Template

        private class TemplateModel
        {
            public object MyProperty { get; set; }
        }

        [Fact]
        public void TemplateNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => TemplateHelpers.Template(html, null, "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                               null /* additionalViewData */, TemplateHelperSpy),
                "expression");
        }

        [Fact]
        public void TemplateDataNotFound()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act
            string result = TemplateHelpers.Template(html, "UnknownObject", "templateName", null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = (null), HtmlFieldName = UnknownObject, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateHtmlFieldNameReplacesExpression()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act
            string result = TemplateHelpers.Template(html, "UnknownObject", "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                                     new { foo = "Bar" }, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = (null), HtmlFieldName = htmlFieldName, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = { foo: Bar }", result);
        }

        [Fact]
        public void TemplateDataFoundInViewDataDictionaryHasNoPropertyName()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);
            html.ViewContext.ViewData["Key"] = 42;

            // Act
            string result = TemplateHelpers.Template(html, "Key", null, null, DataBoundControlMode.Edit, null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Int32, RealModelType = System.Int32, PropertyName = (null), HtmlFieldName = Key, TemplateName = (null), Mode = Edit, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateDataFoundInViewDataDictionarySubPropertyHasPropertyName()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);
            html.ViewContext.ViewData["Key"] = new TemplateModel { MyProperty = "Hello!" };

            // Act
            string result = TemplateHelpers.Template(html, "Key.MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = Key.MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateDataFoundInModelHasPropertyName()
        {
            // Arrange
            HtmlHelper<TemplateModel> html = MakeHtmlHelper<TemplateModel>(new TemplateModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.Template(html, "MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateNullDataFoundInModelHasPropertyTypeInsteadOfActualModelType()
        {
            // Arrange
            HtmlHelper<TemplateModel> html = MakeHtmlHelper<TemplateModel>(new TemplateModel());

            // Act
            string result = TemplateHelpers.Template(html, "MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        // TemplateFor

        private class TemplateForModel
        {
            public int MyField = 0;
            public object MyProperty { get; set; }
            public Nullable<int> MyNullableProperty { get; set; }
        }

        [Fact]
        public void TemplateForNonUnsupportedExpressionTypeThrows()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper<TemplateForModel>(null);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => TemplateHelpers.TemplateFor(html, model => new Object(), "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                                  null /* additionalViewData */, TemplateHelperSpy),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void TemplateForWithNonNullExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, "templateName", null, DataBoundControlMode.ReadOnly,
                                                        new { foo = "Bar" }, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = { foo: Bar }", result);
        }

        [Fact]
        public void TemplateForHtmlFieldNameReplacesExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, "templateName", "htmlFieldName",
                                                        DataBoundControlMode.ReadOnly, null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = htmlFieldName, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullModelStillRetainsTypeInformation()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper<TemplateForModel>(null);

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullPropertyStillRetainsTypeInformation()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullableValueTYpePropertyRetainsNullableValueTYpeForNullPropertyValue()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyNullableProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], RealModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = MyNullableProperty, HtmlFieldName = MyNullableProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullableValueTypePropertyRetainsNullableValueTypeForNonNullPropertyValue()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyNullableProperty = 42 });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyNullableProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], RealModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = MyNullableProperty, HtmlFieldName = MyNullableProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForWithParameterExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, ModelType = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, RealModelType = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, PropertyName = (null), HtmlFieldName = (empty), TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForWithFieldExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyField = 42 });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyField, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Int32, RealModelType = System.Int32, PropertyName = (null), HtmlFieldName = MyField, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        // TemplateHelper

        private class TemplateHelperModel
        {
            public string MyProperty { get; set; }
        }

        [Fact]
        public void TemplateHelperNonNullNonEmptyStringModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperEmptyStringModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.ConvertEmptyStringToNull = false;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = , ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperConvertsEmptyStringsToNull()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.ConvertEmptyStringToNull = true;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperConvertsNullModelsToNullDisplayTextInReadOnlyMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.NullDisplayText = "NullDisplayText";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = NullDisplayText, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperDoesNotConvertNullModelsToNullDisplayTextInEditMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.NullDisplayText = "NullDisplayText";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperAppliesDisplayFormatStringInReadOnlyMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.DisplayFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello world!, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperDoesNotApplyDisplayFormatStringInReadOnlyModeForNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.DisplayFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperAppliesEditFormatStringInEditMode()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.EditFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello world!, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperDoesNotApplyEditFormatStringInEditModeForNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.EditFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperAddsNonNullModelToVisitedObjects()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary viewData = null;

            // Act
            TemplateHelpers.TemplateHelper(
                html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
                (_html, _viewData, _templateName, _mode, _getViews, _getDefaultActions) =>
                {
                    viewData = _viewData;
                    return String.Empty;
                });

            // Assert
            Assert.NotNull(viewData);
            Assert.True(viewData.TemplateInfo.VisitedObjects.Contains("Hello"));
        }

        [Fact]
        public void TemplateHelperAddsNullModelsTypeToVisitedObjects()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary viewData = null;

            // Act
            TemplateHelpers.TemplateHelper(
                html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
                (_html, _viewData, _templateName, _mode, _getViews, _getDefaultActions) =>
                {
                    viewData = _viewData;
                    return String.Empty;
                });

            // Assert
            Assert.NotNull(viewData);
            Assert.True(viewData.TemplateInfo.VisitedObjects.Contains(typeof(string)));
        }

        [Fact]
        public void TemplateHelperReturnsEmptyStringForAlreadyVisitedObject()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            html.ViewData.TemplateInfo.VisitedObjects.Add("Hello");

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void TemplateHelperReturnsEmptyStringForAlreadyVisitedType()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void TemplateHelperPreservesSameInstanceOfModelMetadata()
        { // DDB #225858
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */,
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotNull(callbackViewData);
            Assert.Same(metadata, callbackViewData.ModelMetadata);
        }

        [Fact]
        public void TemplateHelperFormatsValuesUsingCurrentCulture()
        {
            CultureInfo existingCulture = Thread.CurrentThread.CurrentCulture;

            try
            {
                // Arrange
                Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("es-PR");
                HtmlHelper html = MakeHtmlHelper(new { MyProperty = new DateTime(2009, 11, 18, 16, 12, 8, DateTimeKind.Utc) });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                metadata.DisplayFormatString = "{0:F}";

                // Act
                string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                               null /* additionalViewData */, ExecuteTemplateSpy);

                // Assert
                Assert.Equal("Model = 18/11/2009 04:12:08 p.m., ModelType = System.DateTime, RealModelType = System.DateTime, PropertyName = MyProperty, FormattedModelValue = miércoles, 18 de noviembre de 2009 04:12:08 p.m., HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = existingCulture;
            }
        }

        [Fact]
        public void TemplateHelperPreservesExistingViewData()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            html.ViewData["Foo"] = "Bar";
            html.ViewData["Baz"] = 42;
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */,
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotSame(html.ViewData, callbackViewData);
            Assert.Equal(2, callbackViewData.Count);
            Assert.Equal("Bar", callbackViewData["Foo"]);
            Assert.Equal(42, callbackViewData["Baz"]);
        }

        [Fact]
        public void TemplateHelperMergesAdditionalViewData()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            html.ViewData["Foo"] = "Bar";
            html.ViewData["Baz"] = 42;
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           new { foo = "New Foo", hello = "World!" },
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotSame(h