Beispiel #1
0
        public void Display_FindsModel_IfNoViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel {
                Property1 = "Model string"
            };
            var viewData = new ViewDataDictionary <ObjectTemplateModel>(model);
            var html     = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);

            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;

            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Display("Property1");
            }

            // Assert
            Assert.Equal("Model string", result.ToString());
        }
Beispiel #2
0
        public void ObjectTemplateWithShowForEditorMetadata()
        {
            string expected = @"<div class=""editor-label""><label for=""FieldPrefix_Property1"">Property1</label></div>
<div class=""editor-field"">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>
";

            // Arrange
            ObjectTemplateModel          model         = new ObjectTemplateModel();
            HtmlHelper                   html          = MakeHtmlHelper <ObjectTemplateModel>(model);
            Mock <ModelMetadataProvider> provider      = new Mock <ModelMetadataProvider>();
            Func <object>                accessor      = () => model;
            Mock <ModelMetadata>         metadata      = new Mock <ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata                prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1")
            {
                ShowForEdit = true
            };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2")
            {
                ShowForEdit = false
            };

            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Expect(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.AreEqual(expected, result);
        }
        public void ObjectTemplateWithDisplayNameMetadata()
        {
            string expected =
                "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine
                + "<div class=\"display-label\">Custom display name</div>" + Environment.NewLine
                + "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel          model         = new ObjectTemplateModel();
            HtmlHelper                   html          = MakeHtmlHelper <ObjectTemplateModel>(model);
            Mock <ModelMetadataProvider> provider      = new Mock <ModelMetadataProvider>();
            Func <object>                accessor      = () => model;
            Mock <ModelMetadata>         metadata      = new Mock <ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata                prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1")
            {
                DisplayName = String.Empty
            };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2")
            {
                DisplayName = "Custom display name"
            };

            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }
Beispiel #4
0
        public void DisplayFor_FindsModel_EvenIfNull()
        {
            var model    = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary <ObjectTemplateModel>(model);

            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);

            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;

            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.DisplayFor(m => m.Property1);
            }

            // Assert
            Assert.Empty(result.ToString());
        }
        public void ObjectTemplatePreventsRecursionOnModelTypeForNullModelValues()
        {
            string expected =
                "<div class=\"display-label\">Property2</div>" + Environment.NewLine
                + "<div class=\"display-field\">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel          model         = new ObjectTemplateModel();
            HtmlHelper                   html          = MakeHtmlHelper <ObjectTemplateModel>(model);
            Mock <ModelMetadataProvider> provider      = new Mock <ModelMetadataProvider>();
            Func <object>                accessor      = () => model;
            Mock <ModelMetadata>         metadata      = new Mock <ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata                prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1");
            ModelMetadata                prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");

            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }
        public void EditorFor_FindsModel_EvenIfNull()
        {
            var model    = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary <ObjectTemplateModel>(model);

            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);

            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;

            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.EditorFor(m => m.Property1);
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"\" />",
                result.ToString());
        }
Beispiel #7
0
        public void ObjectTemplateDisplaysSimpleDisplayTextWhenTemplateDepthGreaterThanOne(
            string text,
            bool htmlEncode,
            string expectedResult
            )
        {
            // Arrange
            ObjectTemplateModel model    = new ObjectTemplateModel();
            HtmlHelper          html     = MakeHtmlHelper <ObjectTemplateModel>(model);
            ModelMetadata       metadata = ModelMetadataProviders.Current.GetMetadataForType(
                () => model,
                typeof(ObjectTemplateModel)
                );

            metadata.SimpleDisplayText = text;
            metadata.HtmlEncode        = htmlEncode;

            html.ViewData.ModelMetadata = metadata;
            html.ViewData.TemplateInfo.VisitedObjects.Add("foo");
            html.ViewData.TemplateInfo.VisitedObjects.Add("bar");

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expectedResult, result);
        }
Beispiel #8
0
        public void ObjectTemplateDisplaysSimplePropertiesOnObjectByDefault()
        {
            string expected =
                "<div class=\"display-label\">Property1</div>"
                + Environment.NewLine
                + "<div class=\"display-field\">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>"
                + Environment.NewLine
                + "<div class=\"display-label\">Property2</div>"
                + Environment.NewLine
                + "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>"
                + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel
            {
                Property1 = "p1",
                Property2 = null
            };
            HtmlHelper html = MakeHtmlHelper <ObjectTemplateModel>(model);

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }
Beispiel #9
0
        public void ObjectTemplatePreventsRecursionOnModelTypeForNullModelValues()
        {
            string expected = @"<div class=""editor-label""><label for=""FieldPrefix_Property2"">Property2</label></div>
<div class=""editor-field"">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>
";

            // Arrange
            ObjectTemplateModel          model         = new ObjectTemplateModel();
            HtmlHelper                   html          = MakeHtmlHelper <ObjectTemplateModel>(model);
            Mock <ModelMetadataProvider> provider      = new Mock <ModelMetadataProvider>();
            Func <object>                accessor      = () => model;
            Mock <ModelMetadata>         metadata      = new Mock <ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata                prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1");
            ModelMetadata                prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");

            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Expect(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.AreEqual(expected, result);
        }
Beispiel #10
0
        public void CollectionTemplateWrappingObjectTemplate_EncodesSimpleDisplayTextOfItems_IfHtmlEncode(
            string text,
            bool htmlEncode,
            string expectedResult
            )
        {
            // Arrange
            var innerModel = new ObjectTemplateModel
            {
                Property1 = text, // SimpleDisplayText uses first property by default.
            };
            var model    = new[] { innerModel, innerModel, };
            var viewData = new ViewDataDictionary <ObjectTemplateModel[]>(model);
            var html     = MvcHelper.GetHtmlHelper(viewData);

            // GetHtmlHelper does not mock enough of the ViewContext for TemplateHelpers use.
            var viewContext = Mock.Get(html.ViewContext);

            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            // Developers might need to do something similar (including MetadataOverrideScope or another approach
            // replacing ModelMetadataProviders.Current) since for example [DisplayFormat] cannot be applied to a class.
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(
                () => null,
                typeof(ObjectTemplateModel)
                );

            metadata.HtmlEncode = htmlEncode;

            string editorResult;
            string editorForResult;
            string editorForModelResult;

            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    editorResult         = html.Editor("").ToHtmlString();
                    editorForResult      = html.EditorFor(m => m).ToHtmlString();
                    editorForModelResult = html.EditorForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult + expectedResult, editorResult);
            Assert.Equal(expectedResult + expectedResult, editorForResult);
            Assert.Equal(expectedResult + expectedResult, editorForModelResult);
        }
        public void CollectionTemplateWrappingObjectTemplate_EncodesSimpleDisplayTextOfItems_IfHtmlEncode(
            string text,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            var innerModel = new ObjectTemplateModel
            {
                Property1 = text,           // SimpleDisplayText uses first property by default.
            };
            var model = new[] { innerModel, innerModel, };
            var viewData = new ViewDataDictionary<ObjectTemplateModel[]>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            // GetHtmlHelper does not mock enough of the ViewContext for TemplateHelpers use.
            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            // Developers might need to do something similar (including MetadataOverrideScope or another approach
            // replacing ModelMetadataProviders.Current) since for example [DisplayFormat] cannot be applied to a class.
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(ObjectTemplateModel));
            metadata.HtmlEncode = htmlEncode;

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    editorResult = html.Editor("").ToHtmlString();
                    editorForResult = html.EditorFor(m => m).ToHtmlString();
                    editorForModelResult = html.EditorForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult + expectedResult, editorResult);
            Assert.Equal(expectedResult + expectedResult, editorForResult);
            Assert.Equal(expectedResult + expectedResult, editorForModelResult);
        }
Beispiel #12
0
        public void ObjectTemplateDisplaysSimpleDisplayTextWithNonNullModelTemplateDepthGreaterThanOne()
        {
            // Arrange
            ObjectTemplateModel model    = new ObjectTemplateModel();
            HtmlHelper          html     = MakeHtmlHelper <ObjectTemplateModel>(model);
            ModelMetadata       metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(ObjectTemplateModel));

            html.ViewData.ModelMetadata = metadata;
            metadata.NullDisplayText    = "Null Display Text";
            metadata.SimpleDisplayText  = "Simple Display Text";
            html.ViewData.TemplateInfo.VisitedObjects.Add("foo");
            html.ViewData.TemplateInfo.VisitedObjects.Add("bar");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.AreEqual(metadata.SimpleDisplayText, result);
        }
Beispiel #13
0
        public void ObjectTemplateEditsSimplePropertiesOnObjectByDefault()
        {
            string expected = @"<div class=""editor-label""><label for=""FieldPrefix_Property1"">Property1</label></div>
<div class=""editor-field"">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>
<div class=""editor-label""><label for=""FieldPrefix_Property2"">Property2</label></div>
<div class=""editor-field"">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>
";

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel {
                Property1 = "p1", Property2 = null
            };
            HtmlHelper html = MakeHtmlHelper <ObjectTemplateModel>(model);

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.AreEqual(expected, result);
        }
Beispiel #14
0
        public void ObjectTemplateWithModelError()
        {
            string expected = @"<div class=""editor-label""><label for=""FieldPrefix_Property1"">Property1</label></div>
<div class=""editor-field"">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) <span class=""field-validation-error"">Error Message</span></div>
<div class=""editor-label""><label for=""FieldPrefix_Property2"">Property2</label></div>
<div class=""editor-field"">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>
";

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel {
                Property1 = "p1", Property2 = null
            };
            HtmlHelper html = MakeHtmlHelper <ObjectTemplateModel>(model);

            html.ViewData.ModelState.AddModelError("FieldPrefix.Property1", "Error Message");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.AreEqual(expected, result);
        }
Beispiel #15
0
        public void ObjectTemplateWithHiddenHtml()
        {
            string expected =
                "Model = propValue1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)";

            // Arrange
            ObjectTemplateModel          model    = new ObjectTemplateModel();
            HtmlHelper                   html     = MakeHtmlHelper <ObjectTemplateModel>(model);
            Mock <ModelMetadataProvider> provider = new Mock <ModelMetadataProvider>();
            Func <object>                accessor = () => model;
            Mock <ModelMetadata>         metadata = new Mock <ModelMetadata>(
                provider.Object,
                null,
                accessor,
                typeof(ObjectTemplateModel),
                null
                );
            ModelMetadata prop1Metadata = new ModelMetadata(
                provider.Object,
                typeof(ObjectTemplateModel),
                () => "propValue1",
                typeof(string),
                "Property1"
                )
            {
                HideSurroundingHtml = true
            };

            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata });

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }
        public void EditorFor_FindsModel_EvenIfNull()
        {
            var model = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.EditorFor(m => m.Property1);
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"\" />",
                result.ToString());
        }
        public void Display_FindsModel_IfNoViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Display("Property1");
            }

            // Assert
            Assert.Equal("Model string", result.ToString());
        }
        public void DisplayFor_FindsModel_EvenIfNull()
        {
            var model = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.DisplayFor(m => m.Property1);
            }

            // Assert
            Assert.Empty(result.ToString());
        }