public void CheckBoxNotInTemplate_GetsValueFromPropertyOfViewDataEntry()
{
// Arrange
var expected =
@"<input checked=""HtmlEncode[[checked]]"" id=""HtmlEncode[[Prefix_Property1]]"" " +
@"name=""HtmlEncode[[Prefix.Property1]]"" type=""HtmlEncode[[checkbox]]"" value=""HtmlEncode[[true]]"" />" +
@"<input name=""HtmlEncode[[Prefix.Property1]]"" type=""HtmlEncode[[hidden]]"" value=""HtmlEncode[[false]]"" />";
var helper = DefaultTemplatesUtilities.GetHtmlHelper(GetTestModelViewData());
helper.ViewContext.ClientValidationEnabled = false;
helper.ViewData.Remove(nameof(TestModel.Property1));
helper.ViewData["Prefix"] = new TestModel {
Property1 = true
};
helper.ViewData.Model = new TestModel();
// Act
var html = helper.CheckBox("Prefix.Property1", isChecked: null, htmlAttributes: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void CheckBoxInTemplate_GetsModelValue_IfModelStateAndViewDataEmpty()
{
// Arrange
var expected =
@"<input checked=""HtmlEncode[[checked]]"" id=""HtmlEncode[[Prefix_Property1]]"" " +
@"name=""HtmlEncode[[Prefix.Property1]]"" type=""HtmlEncode[[checkbox]]"" value=""HtmlEncode[[true]]"" />" +
@"<input name=""HtmlEncode[[Prefix.Property1]]"" type=""HtmlEncode[[hidden]]"" value=""HtmlEncode[[false]]"" />";
var metadataProvider = new EmptyModelMetadataProvider();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary <TestModel>(metadataProvider));
helper.ViewContext.ClientValidationEnabled = false;
helper.ViewData.Model = new TestModel {
Property1 = true
};
helper.ViewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
// Act
var html = helper.CheckBox("Property1", isChecked: null, htmlAttributes: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void CheckBoxWithNullExpression_DoesNotThrow_WithNameAttribute()
{
// Arrange
var expected = @"<input class=""HtmlEncode[[some-class]]"" name=""HtmlEncode[[-expression-]]"" " +
@"type=""HtmlEncode[[checkbox]]"" value=""HtmlEncode[[true]]"" /><input " +
@"name=""HtmlEncode[[-expression-]]"" type=""HtmlEncode[[hidden]]"" value=""HtmlEncode[[false]]"" />";
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model: false);
helper.ViewContext.ClientValidationEnabled = false;
var attributes = new Dictionary <string, object>
{
{ "class", "some-class" },
{ "name", "-expression-" },
};
// Act
var html = helper.CheckBox(null, isChecked: false, htmlAttributes: attributes);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void HiddenForInTemplate_UsesModelStateValueForComplexExpressions(
Expression <Func <HiddenModel, string> > expression,
string expected)
{
// Arrange
var viewData = GetViewDataWithNullModelAndNonNullViewData();
viewData.ModelState.SetModelValue("pre.Property3[key]", "Prop3Val", "Prop3Val");
viewData.ModelState.SetModelValue("pre.Property4.Property5", "Prop5Val", "Prop5Val");
viewData.ModelState.SetModelValue("pre.Property4.Property6[0]", "Prop6Val", "Prop6Val");
var helper = DefaultTemplatesUtilities.GetHtmlHelper(viewData);
viewData.TemplateInfo.HtmlFieldPrefix = "pre";
var attributes = new { data_val = "true", value = "attr-val" };
// Act
var result = helper.HiddenFor(expression, attributes);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void HiddenInTemplate_UsesPrefixNameToLookupPropertyValueInViewData()
{
// Arrange
var expected = @"<input id=""HtmlEncode[[MyPrefix$Property1]]"" name=""HtmlEncode[[MyPrefix.Property1]]"" type=""HtmlEncode[[hidden]]"" " +
@"value=""HtmlEncode[[vdd-with-prefix]]"" />";
var helper = DefaultTemplatesUtilities.GetHtmlHelper(
GetViewDataWithModelStateAndModelAndViewDataValues(),
idAttributeDotReplacement: "$");
helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";
helper.ViewData.ModelState.Clear();
helper.ViewData.Clear();
helper.ViewData.Add("Property1", "vdd-without-prefix");
helper.ViewData.Add("MyPrefix.Property1", "vdd-with-prefix");
helper.ViewData.Add("MyPrefix$Property1", "vdd-with-iddotreplacement");
// Act
var result = helper.Hidden("Property1", value: null, htmlAttributes: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void CheckBoxFor_UsesModelStateAttemptedValue(string attemptedValue, string expectedChecked)
{
// Arrange
var requiredMessage = ValidationAttributeUtil.GetRequiredErrorMessage("Property1");
var expected =
$@"<input {{0}}data-val=""HtmlEncode[[true]]"" data-val-required=""HtmlEncode[[{requiredMessage}]]"" " +
@"id=""HtmlEncode[[Property1]]"" name=""HtmlEncode[[Property1]]"" type=""HtmlEncode[[checkbox]]"" value=""HtmlEncode[[true]]"" />" +
@"<input name=""HtmlEncode[[Property1]]"" type=""HtmlEncode[[hidden]]"" value=""HtmlEncode[[false]]"" />";
expected = string.Format(CultureInfo.InvariantCulture, expected, expectedChecked);
var viewData = GetTestModelViewData();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(viewData);
viewData.ModelState.SetModelValue("Property1", new string[] { attemptedValue }, attemptedValue);
// Act
var html = helper.CheckBoxFor(m => m.Property1, htmlAttributes: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void TextBoxFor_Throws_IfFullNameEmpty()
{
// Arrange
var expectedMessage = "The name of an HTML field cannot be null or empty. Instead use methods " +
"Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper.Editor or Microsoft.AspNetCore.Mvc.Rendering." +
"IHtmlHelper`1.EditorFor with a non-empty htmlFieldName argument value.";
var htmlAttributes = new
{
attr = "value",
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper("propValue");
helper.ViewContext.ClientValidationEnabled = false;
// Act & Assert
ExceptionAssert.ThrowsArgument(
() => helper.TextBoxFor(m => m, htmlAttributes),
paramName: "expression",
exceptionMessage: expectedMessage);
}
public void BeginFormWithMethodAndHtmlAttributesParameters_WithAntiforgery_CallsHtmlGeneratorWithExpectedValues(
FormMethod method,
object htmlAttributes)
{
// Arrange
var tagBuilder = new TagBuilder(tagName: "form");
var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var htmlHelper = DefaultTemplatesUtilities.GetHtmlHelper(htmlGenerator.Object);
htmlGenerator
.Setup(g => g.GenerateForm(
htmlHelper.ViewContext,
null, // actionName
null, // controllerName
null, // routeValues
method.ToString().ToLowerInvariant(),
htmlAttributes))
.Returns(tagBuilder)
.Verifiable();
htmlGenerator
.Setup(g => g.GenerateAntiforgery(htmlHelper.ViewContext))
.Returns(HtmlString.Empty)
.Verifiable();
// Guards
Assert.NotNull(htmlHelper.ViewContext);
var writer = Assert.IsAssignableFrom <StringWriter>(htmlHelper.ViewContext.Writer);
var builder = writer.GetStringBuilder();
Assert.NotNull(builder);
// Act
var mvcForm = htmlHelper.BeginForm(method, antiforgery: true, htmlAttributes: htmlAttributes);
// Assert
Assert.NotNull(mvcForm);
Assert.Equal("<form>", builder.ToString());
htmlGenerator.Verify();
}
public void BeginRouteForm_EndForm_RendersAntiforgeryToken()
{
// Arrange
var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
htmlGenerator
.Setup(g => g.GenerateRouteForm(
It.IsAny <ViewContext>(),
It.IsAny <string>(),
It.IsAny <object>(),
It.IsAny <string>(),
It.IsAny <object>()))
.Returns(new TagBuilder("form"));
htmlGenerator
.Setup(g => g.GenerateAntiforgery(It.IsAny <ViewContext>()))
.Returns(new TagBuilder("antiforgery"));
var htmlHelper = DefaultTemplatesUtilities.GetHtmlHelper(htmlGenerator.Object);
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(HtmlEncoder))).Returns(new HtmlTestEncoder());
var viewContext = htmlHelper.ViewContext;
viewContext.HttpContext.RequestServices = serviceProvider.Object;
var writer = viewContext.Writer as StringWriter;
Assert.NotNull(writer);
// Act & Assert
using (var form = htmlHelper.BeginRouteForm(routeValues: null))
{
}
Assert.Equal(
"<form><antiforgery></antiforgery></form>",
writer.GetStringBuilder().ToString());
}
public void ListBox_FindsSelectList()
{
// Arrange
var expectedHtml = "<select id=\"HtmlEncode[[Property1]]\" multiple=\"HtmlEncode[[multiple]]\" name=\"HtmlEncode[[Property1]]\">" +
"<option value=\"HtmlEncode[[0]]\">HtmlEncode[[Zero]]</option>" + Environment.NewLine +
"<option value=\"HtmlEncode[[1]]\">HtmlEncode[[One]]</option>" + Environment.NewLine +
"<option selected=\"HtmlEncode[[selected]]\" value=\"HtmlEncode[[2]]\">HtmlEncode[[Two]]</option>" + Environment.NewLine +
"<option value=\"HtmlEncode[[3]]\">HtmlEncode[[Three]]</option>" + Environment.NewLine +
"</select>";
var metadataProvider = new EmptyModelMetadataProvider();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary <TestModel>(metadataProvider));
helper.ViewContext.ClientValidationEnabled = false;
helper.ViewData.ModelState.SetModelValue("Property1", 2, "2");
helper.ViewData["Property1"] = BasicSelectList;
// Act
var listBoxResult = helper.ListBox("Property1");
// Assert
Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxResult));
}
public void CheckBoxForInTemplate_GeneratesExpectedValue()
{
// Arrange
var requiredMessage = ValidationAttributeUtil.GetRequiredErrorMessage("Property1");
var expected =
$@"<input data-val=""HtmlEncode[[true]]"" data-val-required=""HtmlEncode[[{requiredMessage}]]"" " +
@"id=""HtmlEncode[[MyPrefix_Property1]]"" name=""HtmlEncode[[MyPrefix.Property1]]"" Property3=""HtmlEncode[[PropValue]]"" " +
@"type=""HtmlEncode[[checkbox]]"" value=""HtmlEncode[[true]]"" /><input name=""HtmlEncode[[MyPrefix.Property1]]"" type=""HtmlEncode[[hidden]]"" " +
@"value=""HtmlEncode[[false]]"" />";
var helper = DefaultTemplatesUtilities.GetHtmlHelper(GetTestModelViewData());
helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";
var attributes = new Dictionary <string, object> {
{ "Property3", "PropValue" }
};
// Act
var html = helper.CheckBoxFor(m => m.Property1, attributes);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void ValidationSummary_UsesSpecifiedUsesSpecifiedHtmlAttributesAndExcludesPropertyErrors()
{
// Arrange
var helper = DefaultTemplatesUtilities.GetHtmlHelper();
helper.ViewData.ModelState.AddModelError(string.Empty, "Error for root");
helper.ViewData.ModelState.AddModelError("Property1", "Error for Property1");
// Act
var validationSummaryResult = helper.ValidationSummary(
excludePropertyErrors: true,
message: "Custom Message",
htmlAttributes: new { attr = "value" });
// Assert
Assert.Equal(
"<div attr=\"HtmlEncode[[value]]\" class=\"HtmlEncode[[validation-summary-errors]]\"><span>HtmlEncode[[Custom Message]]</span>" +
Environment.NewLine +
"<ul><li>HtmlEncode[[Error for root]]</li>" + Environment.NewLine +
"</ul></div>",
HtmlContentUtilities.HtmlContentToString(validationSummaryResult));
}
public void ValidationSummary_ClientValidationDisabledAllValid_ReturnsEmpty(
string message,
object htmlAttributes,
string tag,
string ignored)
{
// Arrange
var model = new ValidationModel();
var html = DefaultTemplatesUtilities.GetHtmlHelper(model);
html.ViewContext.ClientValidationEnabled = false;
// Act
var result = html.ValidationSummary(
excludePropertyErrors: false,
message: message,
htmlAttributes: htmlAttributes,
tag: tag);
// Assert
Assert.Equal(HtmlString.Empty, result);
}
public void BeginFormWithActionNameAndControllerNameParameters_CallsHtmlGeneratorWithExpectedValues(
string actionName,
string controllerName)
{
// Arrange
var tagBuilder = new TagBuilder(tagName: "form");
var htmlGenerator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var htmlHelper = DefaultTemplatesUtilities.GetHtmlHelper(htmlGenerator.Object);
htmlGenerator
.Setup(g => g.GenerateForm(
htmlHelper.ViewContext,
actionName,
controllerName,
null, // routeValues
"post", // method
null)) // htmlAttributes
.Returns(tagBuilder)
.Verifiable();
htmlGenerator
.Setup(g => g.GenerateAntiforgery(htmlHelper.ViewContext))
.Returns(HtmlString.Empty)
.Verifiable();
// Guards
Assert.NotNull(htmlHelper.ViewContext);
var writer = Assert.IsAssignableFrom <StringWriter>(htmlHelper.ViewContext.Writer);
var builder = writer.GetStringBuilder();
Assert.NotNull(builder);
// Act
var mvcForm = htmlHelper.BeginForm(actionName, controllerName);
// Assert
Assert.NotNull(mvcForm);
Assert.Equal("<form>", builder.ToString());
htmlGenerator.Verify();
}
public void TextBoxFor_DoesNotThrow_IfFullNameEmpty_WithNameAttribute()
{
// Arrange
var htmlAttributes = new
{
attr = "value",
name = "-expression-",
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper("propValue");
helper.ViewContext.ClientValidationEnabled = false;
// Act
var textBoxForResult = helper.TextBoxFor(m => m, htmlAttributes);
// Assert
Assert.Equal(
"<input attr=\"HtmlEncode[[value]]\" " +
"name=\"HtmlEncode[[-expression-]]\" type=\"HtmlEncode[[text]]\" value=\"HtmlEncode[[propValue]]\" />",
HtmlContentUtilities.HtmlContentToString(textBoxForResult));
}
public void DisplayNameHelpers_ReturnDisplayNameForProperty_IfNonNull(string displayName)
{
// Arrange
var provider = new TestModelMetadataProvider();
provider
.ForProperty <DefaultTemplatesUtilities.ObjectTemplateModel>("Property1")
.DisplayDetails(dd => dd.DisplayName = () => displayName);
var helper = DefaultTemplatesUtilities.GetHtmlHelper(provider: provider);
var enumerableHelper = DefaultTemplatesUtilities.GetHtmlHelperForEnumerable(provider: provider);
// Act
var displayNameResult = helper.DisplayName("Property1");
var displayNameForResult = helper.DisplayNameFor(m => m.Property1);
var displayNameForEnumerableResult = enumerableHelper.DisplayNameFor(m => m.Property1);
// Assert
Assert.Equal(displayName, displayNameResult);
Assert.Equal(displayName, displayNameForResult);
Assert.Equal(displayName, displayNameForEnumerableResult);
}
public void ObjectTemplateDisplaysSimplePropertiesOnObjectByDefault()
{
var expected =
"<div class=\"HtmlEncode[[display-label]]\">HtmlEncode[[Property1]]</div>" + Environment.NewLine
+ "<div class=\"HtmlEncode[[display-field]]\">Model = p1, ModelType = System.String, PropertyName = Property1," +
" SimpleDisplayText = p1</div>" + Environment.NewLine
+ "<div class=\"HtmlEncode[[display-label]]\">HtmlEncode[[Prop2]]</div>" + Environment.NewLine
+ "<div class=\"HtmlEncode[[display-field]]\">Model = (null), ModelType = System.String, PropertyName = Property2," +
" SimpleDisplayText = (null)</div>" + Environment.NewLine;
// Arrange
var model = new DefaultTemplatesUtilities.ObjectTemplateModel {
Property1 = "p1", Property2 = null
};
var html = DefaultTemplatesUtilities.GetHtmlHelper(model);
// Act
var result = DefaultDisplayTemplates.ObjectTemplate(html);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void LabelHelpers_ReturnExpectedElementForProperty_IfDisplayNameEmpty_WithEmptyLabelText()
{
// Arrange
var expectedLabel = "<label for=\"HtmlEncode[[Property1]]\"></label>";
var provider = new TestModelMetadataProvider();
provider
.ForProperty <DefaultTemplatesUtilities.ObjectTemplateModel>("Property1")
.DisplayDetails(dd => dd.DisplayName = () => string.Empty);
var helper = DefaultTemplatesUtilities.GetHtmlHelper(provider: provider);
// Act
var labelResult = helper.Label(
expression: nameof(DefaultTemplatesUtilities.ObjectTemplateModel.Property1),
labelText: string.Empty);
var labelForResult = helper.LabelFor(m => m.Property1, labelText: string.Empty);
// Assert
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelResult));
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelForResult));
}
public void Display_FindsModel_IfNoViewDataMember()
{
// Arrange
var model = new DefaultTemplatesUtilities.ObjectTemplateModel {
Property1 = "Model string"
};
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
// Act
var result = helper.Display("Property1");
// Assert
Assert.Equal("HtmlEncode[[Model string]]", HtmlContentUtilities.HtmlContentToString(result));
}
public void IdAndNameHelpers_ReturnPrefixForModel(string prefix, string expectedId)
{
// Arrange
var helper = DefaultTemplatesUtilities.GetHtmlHelper();
helper.ViewData.TemplateInfo.HtmlFieldPrefix = prefix;
// Act
var idResult = helper.Id(expression: string.Empty);
var idForResult = helper.IdFor(m => m);
var idForModelResult = helper.IdForModel();
var nameResult = helper.Name(expression: string.Empty);
var nameForResult = helper.NameFor(m => m);
var nameForModelResult = helper.NameForModel();
// Assert
Assert.Equal(expectedId, idResult);
Assert.Equal(expectedId, idForResult);
Assert.Equal(expectedId, idForModelResult);
Assert.Equal(prefix, nameResult);
Assert.Equal(prefix, nameForResult);
Assert.Equal(prefix, nameForModelResult);
}
public void ValidationSummary_MultipleErrors_ReturnsExpectedDiv(
bool excludePropertyErrors,
string prefix,
string expected)
{
// Arrange
var model = new ValidationModel();
var html = DefaultTemplatesUtilities.GetHtmlHelper(model);
html.ViewData.TemplateInfo.HtmlFieldPrefix = prefix;
AddMultipleErrors(html.ViewData.ModelState);
// Act
var result = html.ValidationSummary(
excludePropertyErrors,
message: null,
htmlAttributes: null,
tag: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void Display_UsesTemplateName()
{
// Arrange
var model = new SomeModel {
SomeProperty = "ModelValue"
};
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), "DisplayTemplates/SomeTemplate", /*isMainPage*/ false))
.Returns(ViewEngineResult.Found("SomeView", Mock.Of <IView>()))
.Verifiable();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
// Act
var displayResult = helper.Display(expression: "SomeProperty", templateName: "SomeTemplate");
// Assert
viewEngine.Verify();
}
public void ValidationSummary_OneInvalidProperty_ReturnsExpectedDiv(
bool excludePropertyErrors,
bool clientValidationEnabled,
string ignored,
string expected)
{
// Arrange
var model = new ValidationModel();
var html = DefaultTemplatesUtilities.GetHtmlHelper(model);
html.ViewContext.ClientValidationEnabled = clientValidationEnabled;
html.ViewData.ModelState.AddModelError("Property1", "This is my validation message");
// Act
var result = html.ValidationSummary(
excludePropertyErrors,
message: null,
htmlAttributes: null,
tag: null);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void DisplayTextFor_ReturnsSimpleDisplayText_IfSetAndValueNonNull()
{
// Arrange
var model = new OverriddenToStringModel("Ignored text")
{
SimpleDisplay = "Simple display text",
};
var provider = new TestModelMetadataProvider();
provider.ForType <OverriddenToStringModel>().DisplayDetails(dd =>
{
dd.SimpleDisplayProperty = nameof(OverriddenToStringModel.SimpleDisplay);
});
var helper = DefaultTemplatesUtilities.GetHtmlHelper <OverriddenToStringModel>(model: model, provider: provider);
// Act
var result = helper.DisplayTextFor(m => m);
// Assert
Assert.Equal("Simple display text", result);
}
public void CheckBoxFor_WithAttributeDictionary_GeneratesExpectedAttributes()
{
// Arrange
var requiredMessage = ValidationAttributeUtil.GetRequiredErrorMessage("Property1");
var expected =
$@"<input data-val=""HtmlEncode[[true]]"" data-val-required=""HtmlEncode[[{requiredMessage}]]"" " +
@"id=""HtmlEncode[[Property1]]"" name=""HtmlEncode[[Property1]]"" " +
@"Property3=""HtmlEncode[[Property3Value]]"" type=""HtmlEncode[[checkbox]]"" " +
@"value=""HtmlEncode[[true]]"" /><input name=""HtmlEncode[[Property1]]"" " +
@"type=""HtmlEncode[[hidden]]"" value=""HtmlEncode[[false]]"" />";
var helper = DefaultTemplatesUtilities.GetHtmlHelper(GetTestModelViewData());
var attributes = new Dictionary <string, object>
{
{ "Property3", "Property3Value" },
{ "name", "-expression-" }, // overridden
};
// Act
var html = helper.CheckBoxFor(m => m.Property1, attributes);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(html));
}
public void LabelHelpers_ReturnEmptyForModel_IfDisplayNameEmpty()
{
// Arrange
var provider = new TestModelMetadataProvider();
provider
.ForType <DefaultTemplatesUtilities.ObjectTemplateModel>()
.DisplayDetails(dd => dd.DisplayName = () => string.Empty);
var helper = DefaultTemplatesUtilities.GetHtmlHelper(provider: provider);
// Act
var labelResult = helper.Label(expression: string.Empty);
var labelNullResult = helper.Label(expression: null); // null is another alias for current model
var labelForResult = helper.LabelFor(m => m);
var labelForModelResult = helper.LabelForModel();
// Assert
Assert.Empty(HtmlContentUtilities.HtmlContentToString(labelResult));
Assert.Empty(HtmlContentUtilities.HtmlContentToString(labelNullResult));
Assert.Empty(HtmlContentUtilities.HtmlContentToString(labelForResult));
Assert.Empty(HtmlContentUtilities.HtmlContentToString(labelForModelResult));
}
public void ValueHelpersDoNotEncodeValue()
{
// Arrange
var model = new TestModel {
StringProperty = "ModelStringPropertyValue <\"\">"
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper <TestModel>(model);
var viewData = helper.ViewData;
viewData["StringProperty"] = "ViewDataValue <\"\">";
viewData.ModelState.SetModelValue(
"ObjectProperty",
"ObjectPropertyRawValue <\"\">",
"ObjectPropertyAttemptedValue <\"\">");
// Act & Assert
Assert.Equal(
"<{ StringProperty = ModelStringPropertyValue <\"\">, ObjectProperty = (null) }>",
helper.ValueForModel("<{0}>"));
Assert.Equal("<ViewDataValue <\"\">>", helper.Value("StringProperty", "<{0}>"));
Assert.Equal("<ModelStringPropertyValue <\"\">>", helper.ValueFor(m => m.StringProperty, "<{0}>"));
Assert.Equal("ObjectPropertyRawValue <\"\">", helper.ValueFor(m => m.ObjectProperty, format: null));
}
public void LabelHelpers_ReturnExpectedElementForModel_IfDisplayNameEmpty_WithLabelText()
{
// Arrange
var expectedLabel = "<label for=\"\">HtmlEncode[[a label]]</label>";
var provider = new TestModelMetadataProvider();
provider
.ForType <DefaultTemplatesUtilities.ObjectTemplateModel>()
.DisplayDetails(dd => dd.DisplayName = () => string.Empty);
var helper = DefaultTemplatesUtilities.GetHtmlHelper(provider: provider);
// Act
var labelResult = helper.Label(expression: string.Empty, labelText: "a label");
var labelNullResult = helper.Label(expression: null, labelText: "a label");
var labelForResult = helper.LabelFor(m => m, labelText: "a label");
var labelForModelResult = helper.LabelForModel(labelText: "a label");
// Assert
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelResult));
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelNullResult));
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelForResult));
Assert.Equal(expectedLabel, HtmlContentUtilities.HtmlContentToString(labelForModelResult));
}
public void TextBoxFor_ComplexExpressions_UsesModelStateValueForComplexExpressions(
Expression <Func <ComplexModel, string> > expression,
string expected)
{
// Arrange
var model = new ComplexModel();
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model);
helper.ViewData.TemplateInfo.HtmlFieldPrefix = "pre";
helper.ViewData.ModelState.SetModelValue("pre.Property3[key]", "MProp3Val", "MProp3Val");
helper.ViewData.ModelState.SetModelValue("pre.Property4.Property5", "MProp5Val", "MProp5Val");
helper.ViewData.ModelState.SetModelValue("pre.Property4.Property6[0]", "MProp6Val", "MProp6Val");
helper.ViewData.Model.Property3["key"] = "Prop3Val";
helper.ViewData.Model.Property4.Property5 = "Prop5Val";
helper.ViewData.Model.Property4.Property6.Add("Prop6Val");
// Act
var result = helper.TextBoxFor(expression);
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));
}
public void DisplayFor_FindsModel_EvenIfNullOrEmpty(string propertyValue)
{
// Arrange
var model = new DefaultTemplatesUtilities.ObjectTemplateModel {
Property1 = propertyValue,
};
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
helper.ViewData["Property1"] = "ViewData string";
// Act
var result = helper.DisplayFor(m => m.Property1);
// Assert
Assert.Equal(string.Empty, HtmlContentUtilities.HtmlContentToString(result));
}
