public void DisplayFormaAttributetSetsNullDisplayText()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").NullDisplayText);
Assert.AreEqual("(null value)", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NullDisplayText").NullDisplayText);
}
public void DisplayNameAttributeSetsDisplayName()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayNameAttributeModel), "Without").DisplayName);
Assert.AreEqual("Custom property name", provider.GetMetadataForProperty(null, typeof(DisplayNameAttributeModel), "With").DisplayName);
}
public void DataTypeAttributeSetsDataTypeName()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DataTypeModel), "NoAttribute").DataTypeName);
Assert.AreEqual("EmailAddress", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "EmailAddressProperty").DataTypeName);
Assert.AreEqual("CustomDataType", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "CustomDataTypeProperty").DataTypeName);
}
public void DisplayFormatAttributeSetEditFormatString()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").EditFormatString);
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayFormatString").EditFormatString);
Assert.AreEqual("Data {0} format", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayAndEditFormatString").EditFormatString);
}
public void DisplayFormatAttributeSetsConvertEmptyStringToNull()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").ConvertEmptyStringToNull);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullTrue").ConvertEmptyStringToNull);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullFalse").ConvertEmptyStringToNull);
}
public void IsRequiredTests()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NonNullableWithout").IsRequired);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWithout").IsRequired);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWith").IsRequired);
}
public void ScaffoldColumnAttributeSetsShowForEdit()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "NoAttribute").ShowForEdit);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnTrue").ShowForEdit);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnFalse").ShowForEdit);
}
public void ReadOnlyAttributeSetsIsReadOnly()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "NoAttribute").IsReadOnly);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "ReadOnlyTrue").IsReadOnly);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "ReadOnlyFalse").IsReadOnly);
}
public void ReadOnlyTests()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.False(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "NoAttributes").IsReadOnly);
Assert.True(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "ReadOnlyAttribute").IsReadOnly);
Assert.True(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "EditableAttribute").IsReadOnly);
Assert.False(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "BothAttributes").IsReadOnly);
}
public void DataAnnotationsModelMetadataProvider_ReadsScaffoldColumnAttribute_ForShowForEdit()
{
// Arrange
var type = typeof(ScaffoldColumnModel);
var provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.True(provider.GetMetadataForProperty(null, type, "NoAttribute").ShowForEdit);
Assert.True(provider.GetMetadataForProperty(null, type, "ScaffoldColumnTrue").ShowForEdit);
Assert.False(provider.GetMetadataForProperty(null, type, "ScaffoldColumnFalse").ShowForEdit);
}
public async Task ProcessAsync_GeneratesExpectedOutput(
object model,
Type containerType,
Func <object> modelAccessor,
NameAndId nameAndId,
string ignored)
{
// Arrange
var originalAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var originalContent = "original content";
var originalTagName = "not-select";
var expectedAttributes = new Dictionary <string, string>(originalAttributes)
{
{ "id", nameAndId.Id },
{ "name", nameAndId.Name },
{ "valid", "from validation attributes" },
};
var expectedContent = originalContent;
var expectedTagName = "select";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
// Property name is either nameof(Model.Text) or nameof(NestedModel.Text).
var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text");
var modelExpression = new ModelExpression(nameAndId.Name, metadata);
var tagHelperContext = new TagHelperContext(new Dictionary <string, object>());
var output = new TagHelperOutput(originalTagName, originalAttributes, expectedContent)
{
SelfClosing = true,
};
var htmlGenerator = new TestableHtmlGenerator(metadataProvider)
{
ValidationAttributes =
{
{ "valid", "from validation attributes" },
}
};
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
var tagHelper = new SelectTagHelper
{
For = modelExpression,
Generator = htmlGenerator,
ViewContext = viewContext,
};
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
protected virtual void UpdateContentTypePropertyFromPropertyInfo(ContentType.ContentTypeProperty contentTypeProperty, PropertyInfo propertyInfo,
Type containerType, object containerTypeInstance)
{
//TODO: Attention, modification de InvariantCulture impossible (pour l'instant)... a traiter
var propertyModelMetadataBasedOnDataAnnotationsModelMetadataProvider =
_dataAnnotationsModelMetadataProvider.GetMetadataForProperty(() => containerTypeInstance, containerType, propertyInfo.Name);
UpdateContentTypePropertyFromModelMetadata(contentTypeProperty, propertyModelMetadataBasedOnDataAnnotationsModelMetadataProvider);
}
//Private method to get display name for other property from metadata object
private string GetDisplayNameForProperty(string propertyName, ModelMetadata metadata)
{
Type type = Type.GetType(metadata.ContainerType.FullName);
var model = Activator.CreateInstance(type);
var provider = new DataAnnotationsModelMetadataProvider();
var otherMetaData = provider.GetMetadataForProperty(() => model, type, propertyName);
return(otherMetaData.DisplayName);
}
public void DataTypeWithoutDisplayFormatOverrideUsesDataTypesDisplayFormat()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithoutDisplayFormatOverride").DisplayFormatString;
// Assert
Assert.AreEqual("{0:C}", result); // Currency's default format string
}
private static ModelMetadata GetMetadataForCanUpdateProperty(string propertyName)
{
DataAnnotationsModelMetadataProvider metadataProvider =
new DataAnnotationsModelMetadataProvider();
return(metadataProvider.GetMetadataForProperty(
null,
typeof(MyModelTestingCanUpdateProperty),
propertyName
));
}
public async Task TagHelper_LeavesOutputUnchanged_IfForNotBound()
{
// Arrange
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var expectedTagName = "textarea";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(
modelAccessor: () => null,
containerType: typeof(Model),
propertyName: nameof(Model.Text));
var modelExpression = new ModelExpression(nameof(Model.Text), metadata);
var tagHelper = new TextAreaTagHelper();
var tagHelperContext = new TagHelperContext(
allAttributes: new Dictionary <string, object>(),
uniqueId: "test",
getChildContentAsync: () => Task.FromResult("Something"));
var output = new TagHelperOutput(expectedTagName, expectedAttributes)
{
PreContent = expectedPreContent,
Content = expectedContent,
PostContent = expectedPostContent,
SelfClosing = true,
};
var htmlGenerator = new TestableHtmlGenerator(metadataProvider)
{
ValidationAttributes =
{
{ "valid", "from validation attributes" },
}
};
Model model = null;
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
tagHelper.ViewContext = viewContext;
tagHelper.Generator = htmlGenerator;
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.True(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
public void DataTypeWithDisplayFormatOverrideUsesDisplayFormatOverride()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithDisplayFormatOverride").DisplayFormatString;
// Assert
Assert.AreEqual("format override", result);
}
public void GetMetadataForPropertySetsTypeAndPropertyName() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
ModelMetadata result = provider.GetMetadataForProperty(null, typeof(string), "Length");
// Assert
Assert.AreEqual(typeof(int), result.ModelType);
Assert.AreEqual("Length", result.PropertyName);
}
public void HiddenAttributeSetsTemplateHintAndHideSurroundingHtml() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
ModelMetadata noAttributeMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "NoAttribute");
Assert.IsNull(noAttributeMetadata.TemplateHint);
Assert.IsFalse(noAttributeMetadata.HideSurroundingHtml);
ModelMetadata defaultHiddenMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "DefaultHidden");
Assert.AreEqual("HiddenInput", defaultHiddenMetadata.TemplateHint);
Assert.IsFalse(defaultHiddenMetadata.HideSurroundingHtml);
ModelMetadata hiddenWithDisplayValueFalseMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenWithDisplayValueFalse");
Assert.AreEqual("HiddenInput", hiddenWithDisplayValueFalseMetadata.TemplateHint);
Assert.IsTrue(hiddenWithDisplayValueFalseMetadata.HideSurroundingHtml);
// [UIHint] overrides the template hint from [Hidden]
Assert.AreEqual("CustomUIHint", provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenAndUIHint").TemplateHint);
}
public void ReadOnlyTests(string propertyName, bool expected)
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act
var actual = provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), propertyName).IsReadOnly;
// Assert
Assert.Equal(expected, actual);
}
public void UIHintAttributeSetsTemplateHint()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoAttribute").TemplateHint);
Assert.AreEqual("MyCustomTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "DefaultUIHint").TemplateHint);
Assert.AreEqual("MyMvcTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "MvcUIHint").TemplateHint);
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoMvcUIHint").TemplateHint);
#if false
// This test won't pass until MVC 3, because there is a bug in UIHintAttribute which causes
// only single instances of it to be returned from type descriptors. Dev10 Bugs #659308
// If the application targets 4.0, they will get the correct behavior, because we've
// implemented it, but the unit test targets 3.5 SP1 and therefore won't pass. As a work-
// around, users who target 3.5 should only use a single [UIHint] attribute.
Assert.AreEqual("MyMvcTemplate", provider.GetMetadataForProperty(typeof(UIHintModel), "MultipleUIHint").TemplateHint);
#endif
}
public void GetMetadataForPropertySetsTypeAndPropertyName()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
ModelMetadata result = provider.GetMetadataForProperty(null, typeof(string), "Length");
// Assert
Assert.AreEqual(typeof(int), result.ModelType);
Assert.AreEqual("Length", result.PropertyName);
}
public static HtmlString ToolTipFor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression)
{
var exp = (MemberExpression)expression.Body;
DataAnnotationsModelMetadataProvider prov = new DataAnnotationsModelMetadataProvider();
var metadataForProperty = prov.GetMetadataForProperty(null, exp.Expression.Type, exp.Member.Name);
if (metadataForProperty.AdditionalValues.ContainsKey("Tooltip"))
{
return(new HtmlString((string)metadataForProperty.AdditionalValues["Tooltip"]));
}
return(new HtmlString(""));
}
public async Task TagHelper_RestoresTypeAndValue_IfForNotBound()
{
// Arrange
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
{ "type", "datetime" },
{ "value", "2014-10-15T23:24:19.000-7:00" },
};
var expectedContent = "original content";
var expectedTagName = "original tag name";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(
modelAccessor: () => null,
containerType: typeof(Model),
propertyName: nameof(Model.Text));
var modelExpression = new ModelExpression(nameof(Model.Text), metadata);
var tagHelperContext = new TagHelperContext(new Dictionary <string, object>());
var output = new TagHelperOutput(expectedTagName, expectedAttributes, expectedContent)
{
SelfClosing = false,
};
var htmlGenerator = new TestableHtmlGenerator(metadataProvider)
{
ValidationAttributes =
{
{ "valid", "from validation attributes" },
}
};
Model model = null;
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
var tagHelper = new InputTagHelper
{
Generator = htmlGenerator,
ViewContext = viewContext,
};
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
public void HiddenAttributeSetsTemplateHintAndHideSurroundingHtml()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
ModelMetadata noAttributeMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "NoAttribute");
Assert.IsNull(noAttributeMetadata.TemplateHint);
Assert.IsFalse(noAttributeMetadata.HideSurroundingHtml);
ModelMetadata defaultHiddenMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "DefaultHidden");
Assert.AreEqual("HiddenInput", defaultHiddenMetadata.TemplateHint);
Assert.IsFalse(defaultHiddenMetadata.HideSurroundingHtml);
ModelMetadata hiddenWithDisplayValueFalseMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenWithDisplayValueFalse");
Assert.AreEqual("HiddenInput", hiddenWithDisplayValueFalseMetadata.TemplateHint);
Assert.IsTrue(hiddenWithDisplayValueFalseMetadata.HideSurroundingHtml);
// [UIHint] overrides the template hint from [Hidden]
Assert.AreEqual("CustomUIHint", provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenAndUIHint").TemplateHint);
}
public void ClientRulesWithCompareAttribute_ErrorMessageUsesPropertyName()
{
// Arrange
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(() => null, typeof(PropertyNameModel), "MyProperty");
var attribute = new CompareAttribute("OtherProperty");
var context = new ClientModelValidationContext(metadata, metadataProvider);
var adapter = new CompareAttributeAdapter(attribute);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("'MyProperty' and 'OtherProperty' do not match.", rule.ErrorMessage);
}
public async Task ProcessAsync_GeneratesExpectedOutput(
object model,
Type containerType,
Func <object> modelAccessor,
string propertyPath,
TagHelperOutputContent tagHelperOutputContent)
{
// Arrange
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
{ "for", tagHelperOutputContent.ExpectedId }
};
var metadataProvider = new DataAnnotationsModelMetadataProvider();
// Property name is either nameof(Model.Text) or nameof(NestedModel.Text).
var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text");
var modelExpression = new ModelExpression(propertyPath, metadata);
var tagHelper = new LabelTagHelper
{
For = modelExpression,
};
var tagHelperContext = new TagHelperContext(allAttributes: new Dictionary <string, object>());
var htmlAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var output = new TagHelperOutput("A random tag name", htmlAttributes, tagHelperOutputContent.OriginalContent);
var expectedTagName = "label";
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
tagHelper.ViewContext = viewContext;
tagHelper.Generator = htmlGenerator;
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(tagHelperOutputContent.ExpectedContent, output.Content);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
public void GetClientValidationRules_ReturnsValidationParameters()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length");
var attribute = new RequiredAttribute();
var adapter = new RequiredAttributeAdapter(attribute);
var context = new ClientModelValidationContext(metadata, provider);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("required", rule.ValidationType);
Assert.Empty(rule.ValidationParameters);
Assert.Equal("The Length field is required.", rule.ErrorMessage);
}
public void ClientRulesWithMaxLengthAttribute()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length");
var attribute = new MaxLengthAttribute(10);
var adapter = new MaxLengthAttributeAdapter(attribute);
var context = new ClientModelValidationContext(metadata, provider);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("maxlength", rule.ValidationType);
Assert.Equal(1, rule.ValidationParameters.Count);
Assert.Equal(10, rule.ValidationParameters["max"]);
Assert.Equal("The field Length must be a string or array type with a maximum length of '10'.", rule.ErrorMessage);
}
public void GetClientValidationRules_ReturnsValidationParameters()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length");
var attribute = new RangeAttribute(typeof(decimal), "0", "100");
var adapter = new RangeAttributeAdapter(attribute);
var context = new ClientModelValidationContext(metadata, provider);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("range", rule.ValidationType);
Assert.Equal(2, rule.ValidationParameters.Count);
Assert.Equal(0m, rule.ValidationParameters["min"]);
Assert.Equal(100m, rule.ValidationParameters["max"]);
Assert.Equal(@"The field Length must be between 0 and 100.", rule.ErrorMessage);
}
public void ClientRulesWithCompareAttribute_ErrorMessageUsesResourceOverride()
{
// Arrange
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(() => null, typeof(PropertyNameModel), "MyProperty");
var attribute = new CompareAttribute("OtherProperty")
{
ErrorMessageResourceName = "CompareAttributeTestResource",
ErrorMessageResourceType = typeof(Test.Resources),
};
var context = new ClientModelValidationContext(metadata, metadataProvider);
var adapter = new CompareAttributeAdapter(attribute);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("Comparing MyProperty to OtherProperty.", rule.ErrorMessage);
}
public void DefaultRequiredClientValidationString()
{
var model = new TestModel {
RequiredStringLength10 = "Arne", Required = "Kalle"
};
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(() => model, typeof(TestModel), "Required");
_stringProvider.Setup(k => k.GetMessage(It.Is <IGetMessageContext>(x => x.Attribute is RequiredAttribute))).Returns(
"The {0} field is required.").Verifiable();
var validator =
_provider.GetValidators(metadata, new ControllerContext(new RequestContext(), new SomeController())).
First();
var clientRules = validator.GetClientValidationRules();
Assert.True(validator.IsRequired);
Assert.Equal("The Required field is required.", clientRules.Single().ErrorMessage);
}
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
Type type = Type.GetType(metadata.ContainerType.FullName);
var model = metadata.Model;
var provider = new DataAnnotationsModelMetadataProvider();
var otherMetaData = provider.GetMetadataForProperty(() => model, type, this.OtherProperty);
var otherPropertyDisplayName = otherMetaData.DisplayName;
var rule = new ModelClientValidationRule()
{
ErrorMessage = FormatErrorMessage(metadata.GetDisplayName(), otherPropertyDisplayName),
ValidationType = ValidationName,
};
rule.ValidationParameters.Add("otherproperty", OtherProperty);
yield return(rule);
}
public void ClientRulesWithMaxLengthAttributeAndCustomMessage()
{
// Arrange
var propertyName = "Length";
var message = "{0} must be at most {1}";
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(() => null, typeof(string), propertyName);
var attribute = new MaxLengthAttribute(5) { ErrorMessage = message };
var adapter = new MaxLengthAttributeAdapter(attribute);
var context = new ClientModelValidationContext(metadata, provider);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("maxlength", rule.ValidationType);
Assert.Equal(1, rule.ValidationParameters.Count);
Assert.Equal(5, rule.ValidationParameters["max"]);
Assert.Equal("Length must be at most 5", rule.ErrorMessage);
}
public void GetClientValidationRules_WithMinAndMaxLength_ReturnsValidationParameters()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length");
var attribute = new StringLengthAttribute(10) { MinimumLength = 3 };
var adapter = new StringLengthAttributeAdapter(attribute);
var context = new ClientModelValidationContext(metadata, provider);
// Act
var rules = adapter.GetClientValidationRules(context);
// Assert
var rule = Assert.Single(rules);
Assert.Equal("length", rule.ValidationType);
Assert.Equal(2, rule.ValidationParameters.Count);
Assert.Equal(3, rule.ValidationParameters["min"]);
Assert.Equal(10, rule.ValidationParameters["max"]);
Assert.Equal("The field Length must be a string with a minimum length of 3 and a maximum length of 10.",
rule.ErrorMessage);
}
public async Task TagHelper_LeavesOutputUnchanged_IfForNotBound2()
{
// Arrange
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var expectedContent = "original content";
var expectedTagName = "original tag name";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForProperty(
modelAccessor: () => null,
containerType: typeof(Model),
propertyName: nameof(Model.Text));
var modelExpression = new ModelExpression(nameof(Model.Text), metadata);
var tagHelper = new LabelTagHelper();
var tagHelperContext = new TagHelperContext(allAttributes: new Dictionary <string, object>());
var output = new TagHelperOutput(expectedTagName, expectedAttributes, expectedContent);
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
Model model = null;
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
tagHelper.ViewContext = viewContext;
tagHelper.Generator = htmlGenerator;
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.Equal(expectedTagName, output.TagName);
}
public void IsRequiredTests() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NonNullableWithout").IsRequired);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWithout").IsRequired);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWith").IsRequired);
}
public void DisplayNameAttributeSetsDisplayName() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayNameAttributeModel), "Without").DisplayName);
Assert.AreEqual("Custom property name", provider.GetMetadataForProperty(null, typeof(DisplayNameAttributeModel), "With").DisplayName);
}
public void ScaffoldColumnAttributeSetsShowForEdit() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "NoAttribute").ShowForEdit);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnTrue").ShowForEdit);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnFalse").ShowForEdit);
}
public void DataTypeWithDisplayFormatOverrideUsesDisplayFormatOverride() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithDisplayFormatOverride").DisplayFormatString;
// Assert
Assert.AreEqual("format override", result);
}
private static ModelMetadata GetModelMetaDataForProperty(Type type, string propertyName)
{
DataAnnotationsModelMetadataProvider modelMetadataProvider = new DataAnnotationsModelMetadataProvider();
return(modelMetadataProvider.GetMetadataForProperty(null, type, propertyName));
}
public async Task ProcessAsync_GeneratesExpectedOutput(
object model,
Type containerType,
Func <object> modelAccessor,
string propertyPath,
TagHelperOutputContent tagHelperOutputContent)
{
// Arrange
var expectedTagName = "not-label";
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
{ "for", tagHelperOutputContent.ExpectedId }
};
var metadataProvider = new DataAnnotationsModelMetadataProvider();
// Property name is either nameof(Model.Text) or nameof(NestedModel.Text).
var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text");
var modelExpression = new ModelExpression(propertyPath, metadata);
var tagHelper = new LabelTagHelper
{
For = modelExpression,
};
var expectedPreContent = "original pre-content";
var expectedPostContent = "original post-content";
var tagHelperContext = new TagHelperContext(
allAttributes: new Dictionary <string, object>(),
uniqueId: "test",
getChildContentAsync: () => Task.FromResult(tagHelperOutputContent.OriginalChildContent));
var htmlAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var output = new TagHelperOutput(expectedTagName, htmlAttributes)
{
PreContent = expectedPreContent,
PostContent = expectedPostContent,
};
// LabelTagHelper checks ContentSet so we don't want to forcibly set it if
// tagHelperOutputContent.OriginalContent is going to be null or empty.
if (!string.IsNullOrEmpty(tagHelperOutputContent.OriginalContent))
{
output.Content = tagHelperOutputContent.OriginalContent;
}
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
tagHelper.ViewContext = viewContext;
tagHelper.Generator = htmlGenerator;
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedPreContent, output.PreContent);
Assert.Equal(tagHelperOutputContent.ExpectedContent, output.Content);
Assert.Equal(expectedPostContent, output.PostContent);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
public void DataAnnotationsNameTests()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.Equal("NoAttribute", provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").GetDisplayName());
Assert.Equal("NothingSet", provider.GetMetadataForProperty(null, typeof(DisplayModel), "NothingSet").GetDisplayName());
Assert.Equal("", provider.GetMetadataForProperty(null, typeof(DisplayModel), "EmptyDisplayName").GetDisplayName());
Assert.Equal("DescriptionSet", provider.GetMetadataForProperty(null, typeof(DisplayModel), "DescriptionSet").GetDisplayName());
Assert.Equal("Name text1", provider.GetMetadataForProperty(null, typeof(DisplayModel), "NameSet").GetDisplayName());
Assert.Equal("Name text2", provider.GetMetadataForProperty(null, typeof(DisplayModel), "BothSet").GetDisplayName());
Assert.NotEqual("String1", Resources.String1);
Assert.Equal(Resources.String1, provider.GetMetadataForProperty(null, typeof(DisplayModel), "Localized").GetDisplayName());
}
public void ReadOnlyAttributeSetsIsReadOnly() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "NoAttribute").IsReadOnly);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "ReadOnlyTrue").IsReadOnly);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(IsReadOnlyModel), "ReadOnlyFalse").IsReadOnly);
}
public void DataTypeAttributeSetsDataTypeName() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DataTypeModel), "NoAttribute").DataTypeName);
Assert.AreEqual("EmailAddress", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "EmailAddressProperty").DataTypeName);
Assert.AreEqual("CustomDataType", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "CustomDataTypeProperty").DataTypeName);
}
public void UIHintAttributeSetsTemplateHint() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoAttribute").TemplateHint);
Assert.AreEqual("MyCustomTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "DefaultUIHint").TemplateHint);
Assert.AreEqual("MyMvcTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "MvcUIHint").TemplateHint);
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoMvcUIHint").TemplateHint);
#if false
// This test won't pass until MVC 3, because there is a bug in UIHintAttribute which causes
// only single instances of it to be returned from type descriptors. Dev10 Bugs #659308
// If the application targets 4.0, they will get the correct behavior, because we've
// implemented it, but the unit test targets 3.5 SP1 and therefore won't pass. As a work-
// around, users who target 3.5 should only use a single [UIHint] attribute.
Assert.AreEqual("MyMvcTemplate", provider.GetMetadataForProperty(typeof(UIHintModel), "MultipleUIHint").TemplateHint);
#endif
}
public void DisplayAttribute_WithLocalizedName()
{
// Guard
var expected = Resources.String1;
Assert.NotEqual("String1", expected);
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act
var actual = provider.GetMetadataForProperty(null, typeof(DisplayModel), "Localized").GetDisplayName();
// Assert
Assert.Equal(expected, actual);
}
public async Task ProcessAsync_GeneratesExpectedOutput_WithItems(
object model,
Type containerType,
Func <object> modelAccessor,
NameAndId nameAndId,
string expectedOptions)
{
// Arrange
var originalAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var originalContent = "original content";
var expectedAttributes = new Dictionary <string, string>(originalAttributes)
{
{ "id", nameAndId.Id },
{ "name", nameAndId.Name },
{ "valid", "from validation attributes" },
};
var expectedContent = originalContent + expectedOptions;
var expectedTagName = "select";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
// Property name is either nameof(Model.Text) or nameof(NestedModel.Text).
var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text");
var modelExpression = new ModelExpression(nameAndId.Name, metadata);
var tagHelperContext = new TagHelperContext(new Dictionary <string, object>());
var output = new TagHelperOutput(expectedTagName, originalAttributes, originalContent)
{
SelfClosing = true,
};
var items = new SelectList(new[] { "", "outer text", "inner text", "other text" });
var htmlGenerator = new TestableHtmlGenerator(metadataProvider)
{
ValidationAttributes =
{
{ "valid", "from validation attributes" },
}
};
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
var tagHelper = new SelectTagHelper
{
For = modelExpression,
Generator = htmlGenerator,
Items = items,
ViewContext = viewContext,
};
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
Assert.NotNull(viewContext.FormContext?.FormData);
var keyValuePair = Assert.Single(
viewContext.FormContext.FormData,
entry => entry.Key == SelectTagHelper.SelectedValuesFormDataKey);
Assert.NotNull(keyValuePair.Value);
var selectedValues = Assert.IsAssignableFrom <ICollection <string> >(keyValuePair.Value);
Assert.InRange(selectedValues.Count, 0, 1);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var propertyTestedInfo = validationContext.ObjectType.GetProperty(this.testedPropertyName);
if (propertyTestedInfo == null)
{
return(new ValidationResult(string.Format("unknown property {0}", this.testedPropertyName)));
}
var propertyTestedValue = propertyTestedInfo.GetValue(validationContext.ObjectInstance, null);
if (value == null || !(value is DateTime))
{
return(ValidationResult.Success);
}
if (propertyTestedValue == null || !(propertyTestedValue is DateTime))
{
return(ValidationResult.Success);
}
// Compare values
if (isDateBefore)
{
if ((DateTime)value <= (DateTime)propertyTestedValue)
{
if (this.allowEqualDates)
{
return(ValidationResult.Success);
}
if ((DateTime)value < (DateTime)propertyTestedValue)
{
return(ValidationResult.Success);
}
}
}
else
{
if ((DateTime)value >= (DateTime)propertyTestedValue)
{
if (this.allowEqualDates)
{
return(ValidationResult.Success);
}
if ((DateTime)value > (DateTime)propertyTestedValue)
{
return(ValidationResult.Success);
}
}
}
//NEED TO GET THE DISPLAY NAME FOR THE OTHER PROPERTY
var provider = new DataAnnotationsModelMetadataProvider();
var otherMetaData = provider.GetMetadataForProperty(() => validationContext.ObjectInstance, validationContext.ObjectType, this.testedPropertyName);
//***************************************************
if (isDateBefore)
{
if (!allowEqualDates)
{
return(new ValidationResult(String.Format(defaultErrorMessage, validationContext.DisplayName, otherMetaData.DisplayName)));
}
else
{
return(new ValidationResult(String.Format(defaultEqualErrorMessage, validationContext.DisplayName, otherMetaData.DisplayName)));
}
}
else
{
if (!allowEqualDates)
{
return(new ValidationResult(String.Format(defaultAfterErrorMessage, validationContext.DisplayName, otherMetaData.DisplayName)));
}
else
{
return(new ValidationResult(String.Format(defaultEqualAfterErrorMessage, validationContext.DisplayName, otherMetaData.DisplayName)));
}
}
}
private static ModelMetadata GetModelMetaDataForProperty(Type type, string propertyName, Func <object> modelCreator)
{
DataAnnotationsModelMetadataProvider modelMetadataProvider = new DataAnnotationsModelMetadataProvider();
return(modelMetadataProvider.GetMetadataForProperty(modelCreator, type, propertyName));
}
public void DisplayFormaAttributetSetsNullDisplayText() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").NullDisplayText);
Assert.AreEqual("(null value)", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NullDisplayText").NullDisplayText);
}
public void DataTypeWithoutDisplayFormatOverrideUsesDataTypesDisplayFormat() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithoutDisplayFormatOverride").DisplayFormatString;
// Assert
Assert.AreEqual("{0:C}", result); // Currency's default format string
}
public void DataAnnotationsDescriptionTests()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").Description);
Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NothingSet").Description);
Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NameSet").Description);
Assert.Equal("Description text1", provider.GetMetadataForProperty(null, typeof(DisplayModel), "DescriptionSet").Description);
Assert.Equal("Description text2", provider.GetMetadataForProperty(null, typeof(DisplayModel), "BothSet").Description);
}
public void DisplayFormatAttributeSetEditFormatString() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").EditFormatString);
Assert.IsNull(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayFormatString").EditFormatString);
Assert.AreEqual("Data {0} format", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayAndEditFormatString").EditFormatString);
}
public void DisplayFormatAttributeSetsConvertEmptyStringToNull() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").ConvertEmptyStringToNull);
Assert.IsTrue(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullTrue").ConvertEmptyStringToNull);
Assert.IsFalse(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullFalse").ConvertEmptyStringToNull);
}
public async Task Process_GeneratesExpectedOutput(
object model,
Type containerType,
Func <object> modelAccessor,
NameAndId nameAndId,
string expectedContent)
{
// Arrange
var expectedAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
{ "id", nameAndId.Id },
{ "name", nameAndId.Name },
{ "valid", "from validation attributes" },
};
var expectedTagName = "not-textarea";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
// Property name is either nameof(Model.Text) or nameof(NestedModel.Text).
var metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName: "Text");
var modelExpression = new ModelExpression(nameAndId.Name, metadata);
var tagHelper = new TextAreaTagHelper
{
For = modelExpression,
};
var tagHelperContext = new TagHelperContext(
allAttributes: new Dictionary <string, object>(),
uniqueId: "test",
getChildContentAsync: () => Task.FromResult("Something"));
var htmlAttributes = new Dictionary <string, string>
{
{ "class", "form-control" },
};
var output = new TagHelperOutput(expectedTagName, htmlAttributes)
{
Content = "original content",
SelfClosing = true,
};
var htmlGenerator = new TestableHtmlGenerator(metadataProvider)
{
ValidationAttributes =
{
{ "valid", "from validation attributes" },
}
};
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
tagHelper.ViewContext = viewContext;
tagHelper.Generator = htmlGenerator;
// Act
await tagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes);
Assert.Equal(expectedContent, output.Content);
Assert.False(output.SelfClosing);
Assert.Equal(expectedTagName, output.TagName);
}
private static ModelMetadata GetMetadataForCanUpdateProperty(string propertyName)
{
DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
return metadataProvider.GetMetadataForProperty(null, typeof(MyModelTestingCanUpdateProperty), propertyName);
}
[InlineData("DisplayNameDefault", "")] // The default for DisplayName is the empty string, we don't have special handling for it, and nither does MVC.
public void DataAnnotationsNameTests(string propertyName, string expected)
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
// Act
var actual = provider.GetMetadataForProperty(null, typeof(DisplayModel), propertyName).GetDisplayName();
// Assert
Assert.Equal(expected, actual);
}